Merge branch 'master' into kimkulling-build-instructions

CMakeLists.txt

@@ -111,9 +111,9 @@ OPTION( INJECT_DEBUG_POSTFIX
 )
 
 IF (IOS)
-	IF (NOT CMAKE_BUILD_TYPE)
- 		SET(CMAKE_BUILD_TYPE "Release")
-	ENDIF (NOT CMAKE_BUILD_TYPE)
+  IF (NOT CMAKE_BUILD_TYPE)
+    SET(CMAKE_BUILD_TYPE "Release")
+  ENDIF (NOT CMAKE_BUILD_TYPE)
 ENDIF (IOS)
 
 # Use subset of Windows.h
@@ -210,8 +210,8 @@ ENDIF( UNIX )
 # Grouped compiler settings
 IF ((CMAKE_C_COMPILER_ID MATCHES "GNU") AND NOT CMAKE_COMPILER_IS_MINGW)
   # hide all not-exported symbols
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fvisibility=hidden -fPIC -Wall -std=c++0x")
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
+  SET(CMAKE_CXX_FLAGS "-g -fvisibility=hidden -fPIC -fno-strict-aliasing -Wall -std=c++0x ${CMAKE_CXX_FLAGS}")
+  SET(CMAKE_C_FLAGS "-fPIC -fno-strict-aliasing ${CMAKE_C_FLAGS}")
   SET(LIBSTDC++_LIBRARIES -lstdc++)
 ELSEIF(MSVC)
   # enable multi-core compilation with MSVC
@@ -224,11 +224,11 @@ ELSEIF(MSVC)
     ADD_COMPILE_OPTIONS(/wd4351)
   ENDIF()
 ELSEIF ( "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" )
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fvisibility=hidden -fPIC -Wall -Wno-long-long -std=c++11" )
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
+  SET(CMAKE_CXX_FLAGS "-g -fvisibility=hidden -fPIC -fno-strict-aliasing -Wall -Wno-long-long -std=c++11 ${CMAKE_CXX_FLAGS}" )
+  SET(CMAKE_C_FLAGS "-fPIC -fno-strict-aliasing ${CMAKE_C_FLAGS}")
 ELSEIF( CMAKE_COMPILER_IS_MINGW )
-  SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -Wall -Wno-long-long -std=c++11" )
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
+  SET( CMAKE_CXX_FLAGS "-fvisibility=hidden -fno-strict-aliasing -Wall -Wno-long-long -std=c++11 -Wa,-mbig-obj ${CMAKE_CXX_FLAGS}" )
+  SET(CMAKE_C_FLAGS "-fPIC -fno-strict-aliasing ${CMAKE_C_FLAGS} ")
   ADD_DEFINITIONS( -U__STRICT_ANSI__ )
 ENDIF()
 

Readme.md

@@ -30,6 +30,8 @@ One-off donations via PayPal:
 
 Please check our Wiki as well: https://github.com/assimp/assimp/wiki
 
+If you want to check our Model-Database, use the following repo: https://github.com/assimp/assimp-mdb
+
 #### Supported file formats ####
 
 __Importers__:

code/AssbinExporter.cpp

@@ -62,33 +62,30 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <time.h>
 
-using namespace Assimp;
-
-namespace Assimp    {
+namespace Assimp {
 
 template <typename T>
-size_t Write(IOStream * stream, const T& v)
-{
+size_t Write(IOStream * stream, const T& v) {
     return stream->Write( &v, sizeof(T), 1 );
 }
 
-
 // -----------------------------------------------------------------------------------
 // Serialize an aiString
 template <>
-inline size_t Write<aiString>(IOStream * stream, const aiString& s)
-{
+inline
+size_t Write<aiString>(IOStream * stream, const aiString& s) {
     const size_t s2 = (uint32_t)s.length;
     stream->Write(&s,4,1);
     stream->Write(s.data,s2,1);
+
     return s2+4;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize an unsigned int as uint32_t
 template <>
-inline size_t Write<unsigned int>(IOStream * stream, const unsigned int& w)
-{
+inline
+size_t Write<unsigned int>(IOStream * stream, const unsigned int& w) {
     const uint32_t t = (uint32_t)w;
     if (w > t) {
         // this shouldn't happen, integers in Assimp data structures never exceed 2^32
@@ -96,114 +93,123 @@ inline size_t Write<unsigned int>(IOStream * stream, const unsigned int& w)
     }
 
     stream->Write(&t,4,1);
+
     return 4;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize an unsigned int as uint16_t
 template <>
-inline size_t Write<uint16_t>(IOStream * stream, const uint16_t& w)
-{
+inline
+size_t Write<uint16_t>(IOStream * stream, const uint16_t& w) {
     static_assert(sizeof(uint16_t)==2, "sizeof(uint16_t)==2");
     stream->Write(&w,2,1);
+
     return 2;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize a float
 template <>
-inline size_t Write<float>(IOStream * stream, const float& f)
-{
+inline
+size_t Write<float>(IOStream * stream, const float& f) {
     static_assert(sizeof(float)==4, "sizeof(float)==4");
     stream->Write(&f,4,1);
+
     return 4;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize a double
 template <>
-inline size_t Write<double>(IOStream * stream, const double& f)
-{
+inline
+size_t Write<double>(IOStream * stream, const double& f) {
     static_assert(sizeof(double)==8, "sizeof(double)==8");
     stream->Write(&f,8,1);
+
     return 8;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize a vec3
 template <>
-inline size_t Write<aiVector3D>(IOStream * stream, const aiVector3D& v)
-{
+inline
+size_t Write<aiVector3D>(IOStream * stream, const aiVector3D& v) {
     size_t t = Write<float>(stream,v.x);
     t += Write<float>(stream,v.y);
     t += Write<float>(stream,v.z);
+
     return t;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize a color value
 template <>
-inline size_t Write<aiColor3D>(IOStream * stream, const aiColor3D& v)
-{
+inline
+size_t Write<aiColor3D>(IOStream * stream, const aiColor3D& v) {
     size_t t = Write<float>(stream,v.r);
     t += Write<float>(stream,v.g);
     t += Write<float>(stream,v.b);
+
     return t;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize a color value
 template <>
-inline size_t Write<aiColor4D>(IOStream * stream, const aiColor4D& v)
-{
+inline
+size_t Write<aiColor4D>(IOStream * stream, const aiColor4D& v) {
     size_t t = Write<float>(stream,v.r);
     t += Write<float>(stream,v.g);
     t += Write<float>(stream,v.b);
     t += Write<float>(stream,v.a);
+
     return t;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize a quaternion
 template <>
-inline size_t Write<aiQuaternion>(IOStream * stream, const aiQuaternion& v)
-{
+inline
+size_t Write<aiQuaternion>(IOStream * stream, const aiQuaternion& v) {
     size_t t = Write<float>(stream,v.w);
     t += Write<float>(stream,v.x);
     t += Write<float>(stream,v.y);
     t += Write<float>(stream,v.z);
     ai_assert(t == 16);
+
     return 16;
 }
 
-
 // -----------------------------------------------------------------------------------
 // Serialize a vertex weight
 template <>
-inline size_t Write<aiVertexWeight>(IOStream * stream, const aiVertexWeight& v)
-{
+inline
+size_t Write<aiVertexWeight>(IOStream * stream, const aiVertexWeight& v) {
     size_t t = Write<unsigned int>(stream,v.mVertexId);
+
     return t+Write<float>(stream,v.mWeight);
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize a mat4x4
 template <>
-inline size_t Write<aiMatrix4x4>(IOStream * stream, const aiMatrix4x4& m)
-{
+inline
+size_t Write<aiMatrix4x4>(IOStream * stream, const aiMatrix4x4& m) {
     for (unsigned int i = 0; i < 4;++i) {
         for (unsigned int i2 = 0; i2 < 4;++i2) {
             Write<float>(stream,m[i][i2]);
         }
     }
+
     return 64;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize an aiVectorKey
 template <>
-inline size_t Write<aiVectorKey>(IOStream * stream, const aiVectorKey& v)
-{
+inline
+size_t Write<aiVectorKey>(IOStream * stream, const aiVectorKey& v) {
     const size_t t = Write<double>(stream,v.mTime);
     return t + Write<aiVector3D>(stream,v.mValue);
 }
@@ -211,16 +217,16 @@ inline size_t Write<aiVectorKey>(IOStream * stream, const aiVectorKey& v)
 // -----------------------------------------------------------------------------------
 // Serialize an aiQuatKey
 template <>
-inline size_t Write<aiQuatKey>(IOStream * stream, const aiQuatKey& v)
-{
+inline
+size_t Write<aiQuatKey>(IOStream * stream, const aiQuatKey& v) {
     const size_t t = Write<double>(stream,v.mTime);
     return t + Write<aiQuaternion>(stream,v.mValue);
 }
 
 template <typename T>
-inline size_t WriteBounds(IOStream * stream, const T* in, unsigned int size)
-{
-    T minc,maxc;
+inline
+size_t WriteBounds(IOStream * stream, const T* in, unsigned int size) {
+    T minc, maxc;
     ArrayBounds(in,size,minc,maxc);
 
     const size_t t = Write<T>(stream,minc);
@@ -230,590 +236,595 @@ inline size_t WriteBounds(IOStream * stream, const T* in, unsigned int size)
 // We use this to write out non-byte arrays so that we write using the specializations.
 // This way we avoid writing out extra bytes that potentially come from struct alignment.
 template <typename T>
-inline size_t WriteArray(IOStream * stream, const T* in, unsigned int size)
-{
+inline
+size_t WriteArray(IOStream * stream, const T* in, unsigned int size) {
     size_t n = 0;
     for (unsigned int i=0; i<size; i++) n += Write<T>(stream,in[i]);
+
     return n;
 }
 
-    // ----------------------------------------------------------------------------------
-    /** @class  AssbinChunkWriter
-     *  @brief  Chunk writer mechanism for the .assbin file structure
-     *
-     *  This is a standard in-memory IOStream (most of the code is based on BlobIOStream),
-     *  the difference being that this takes another IOStream as a "container" in the
-     *  constructor, and when it is destroyed, it appends the magic number, the chunk size,
-     *  and the chunk contents to the container stream. This allows relatively easy chunk
-     *  chunk construction, even recursively.
-     */
-    class AssbinChunkWriter : public IOStream
-    {
-    private:
-
-        uint8_t* buffer;
-        uint32_t magic;
-        IOStream * container;
-        size_t cur_size, cursor, initial;
+// ----------------------------------------------------------------------------------
+/** @class  AssbinChunkWriter
+ *  @brief  Chunk writer mechanism for the .assbin file structure
+ *
+ *  This is a standard in-memory IOStream (most of the code is based on BlobIOStream),
+ *  the difference being that this takes another IOStream as a "container" in the
+ *  constructor, and when it is destroyed, it appends the magic number, the chunk size,
+ *  and the chunk contents to the container stream. This allows relatively easy chunk
+ *  chunk construction, even recursively.
+ */
+class AssbinChunkWriter : public IOStream
+{
+private:
 
-    private:
-        // -------------------------------------------------------------------
-        void Grow(size_t need = 0)
-        {
-            size_t new_size = std::max(initial, std::max( need, cur_size+(cur_size>>1) ));
+    uint8_t* buffer;
+    uint32_t magic;
+    IOStream * container;
+    size_t cur_size, cursor, initial;
 
-            const uint8_t* const old = buffer;
-            buffer = new uint8_t[new_size];
+private:
+    // -------------------------------------------------------------------
+    void Grow(size_t need = 0)
+    {
+        size_t new_size = std::max(initial, std::max( need, cur_size+(cur_size>>1) ));
 
-            if (old) {
-                memcpy(buffer,old,cur_size);
-                delete[] old;
-            }
+        const uint8_t* const old = buffer;
+        buffer = new uint8_t[new_size];
 
-            cur_size = new_size;
+        if (old) {
+            memcpy(buffer,old,cur_size);
+            delete[] old;
         }
 
-    public:
+        cur_size = new_size;
+    }
 
-        AssbinChunkWriter( IOStream * container, uint32_t magic, size_t initial = 4096)
-            : buffer(NULL), magic(magic), container(container), cur_size(0), cursor(0), initial(initial)
-        {
-        }
+public:
 
-        virtual ~AssbinChunkWriter()
-        {
-            if (container) {
-                container->Write( &magic, sizeof(uint32_t), 1 );
-                container->Write( &cursor, sizeof(uint32_t), 1 );
-                container->Write( buffer, 1, cursor );
-            }
-            if (buffer) delete[] buffer;
+    AssbinChunkWriter( IOStream * container, uint32_t magic, size_t initial = 4096)
+        : buffer(NULL), magic(magic), container(container), cur_size(0), cursor(0), initial(initial)
+    {
+    }
+
+    virtual ~AssbinChunkWriter()
+    {
+        if (container) {
+            container->Write( &magic, sizeof(uint32_t), 1 );
+            container->Write( &cursor, sizeof(uint32_t), 1 );
+            container->Write( buffer, 1, cursor );
         }
+        if (buffer) delete[] buffer;
+    }
+
+    void * GetBufferPointer() { return buffer; }
 
-        void * GetBufferPointer() { return buffer; }
+    // -------------------------------------------------------------------
+    virtual size_t Read(void* /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) {
+        return 0;
+    }
+    virtual aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) {
+        return aiReturn_FAILURE;
+    }
+    virtual size_t Tell() const {
+        return cursor;
+    }
+    virtual void Flush() {
+        // not implemented
+    }
 
-        // -------------------------------------------------------------------
-        virtual size_t Read(void* /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) { return 0; }
-        virtual aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) { return aiReturn_FAILURE; }
-        virtual size_t Tell() const { return cursor; }
-        virtual void Flush() { }
+    virtual size_t FileSize() const {
+        return cursor;
+    }
 
-        virtual size_t FileSize() const
-        {
-            return cursor;
+    // -------------------------------------------------------------------
+    virtual size_t Write(const void* pvBuffer, size_t pSize, size_t pCount) {
+        pSize *= pCount;
+        if (cursor + pSize > cur_size) {
+            Grow(cursor + pSize);
         }
 
-        // -------------------------------------------------------------------
-        virtual size_t Write(const void* pvBuffer, size_t pSize, size_t pCount)
-        {
-            pSize *= pCount;
-            if (cursor + pSize > cur_size) {
-                Grow(cursor + pSize);
-            }
+        memcpy(buffer+cursor, pvBuffer, pSize);
+        cursor += pSize;
 
-            memcpy(buffer+cursor, pvBuffer, pSize);
-            cursor += pSize;
+        return pCount;
+    }
 
-            return pCount;
-        }
+};
 
-    };
+// ----------------------------------------------------------------------------------
+/** @class  AssbinExport
+ *  @brief  Assbin exporter class
+ *
+ *  This class performs the .assbin exporting, and is responsible for the file layout.
+ */
+class AssbinExport
+{
+private:
+    bool shortened;
+    bool compressed;
 
-    // ----------------------------------------------------------------------------------
-    /** @class  AssbinExport
-     *  @brief  Assbin exporter class
-     *
-     *  This class performs the .assbin exporting, and is responsible for the file layout.
-     */
-    class AssbinExport
+protected:
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryNode( IOStream * container, const aiNode* node)
     {
-    private:
-        bool shortened;
-        bool compressed;
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODE );
 
-    protected:
+        unsigned int nb_metadata = (node->mMetaData != NULL ? node->mMetaData->mNumProperties : 0);
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryNode( IOStream * container, const aiNode* node)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODE );
+        Write<aiString>(&chunk,node->mName);
+        Write<aiMatrix4x4>(&chunk,node->mTransformation);
+        Write<unsigned int>(&chunk,node->mNumChildren);
+        Write<unsigned int>(&chunk,node->mNumMeshes);
+        Write<unsigned int>(&chunk,nb_metadata);
 
-			unsigned int nb_metadata = (node->mMetaData != NULL ? node->mMetaData->mNumProperties : 0);
+        for (unsigned int i = 0; i < node->mNumMeshes;++i) {
+            Write<unsigned int>(&chunk,node->mMeshes[i]);
+        }
 
-            Write<aiString>(&chunk,node->mName);
-            Write<aiMatrix4x4>(&chunk,node->mTransformation);
-            Write<unsigned int>(&chunk,node->mNumChildren);
-            Write<unsigned int>(&chunk,node->mNumMeshes);
-			Write<unsigned int>(&chunk,nb_metadata);
+        for (unsigned int i = 0; i < node->mNumChildren;++i) {
+            WriteBinaryNode( &chunk, node->mChildren[i] );
+        }
 
-            for (unsigned int i = 0; i < node->mNumMeshes;++i) {
-                Write<unsigned int>(&chunk,node->mMeshes[i]);
-            }
+        for (unsigned int i = 0; i < nb_metadata; ++i) {
+            const aiString& key = node->mMetaData->mKeys[i];
+            aiMetadataType type = node->mMetaData->mValues[i].mType;
+            void* value = node->mMetaData->mValues[i].mData;
 
-            for (unsigned int i = 0; i < node->mNumChildren;++i) {
-                WriteBinaryNode( &chunk, node->mChildren[i] );
-            }
+            Write<aiString>(&chunk, key);
+            Write<uint16_t>(&chunk, type);
 
-			for (unsigned int i = 0; i < nb_metadata; ++i) {
-				const aiString& key = node->mMetaData->mKeys[i];
-				aiMetadataType type = node->mMetaData->mValues[i].mType;
-				void* value = node->mMetaData->mValues[i].mData;
-
-				Write<aiString>(&chunk, key);
-				Write<uint16_t>(&chunk, type);
-				
-				switch (type) {
-                    case AI_BOOL:
-                        Write<bool>(&chunk, *((bool*) value));
-                        break;
-                    case AI_INT32:
-                        Write<int32_t>(&chunk, *((int32_t*) value));
-                        break;
-                    case AI_UINT64:
-                        Write<uint64_t>(&chunk, *((uint64_t*) value));
-                        break;
-                    case AI_FLOAT:
-                        Write<float>(&chunk, *((float*) value));
-                        break;
-                    case AI_DOUBLE:
-                        Write<double>(&chunk, *((double*) value));
-                        break;
-                    case AI_AISTRING:
-                        Write<aiString>(&chunk, *((aiString*) value));
-                        break;
-                    case AI_AIVECTOR3D:
-                        Write<aiVector3D>(&chunk, *((aiVector3D*) value));
-                        break;
+            switch (type) {
+                case AI_BOOL:
+                    Write<bool>(&chunk, *((bool*) value));
+                    break;
+                case AI_INT32:
+                    Write<int32_t>(&chunk, *((int32_t*) value));
+                    break;
+                case AI_UINT64:
+                    Write<uint64_t>(&chunk, *((uint64_t*) value));
+                    break;
+                case AI_FLOAT:
+                    Write<float>(&chunk, *((float*) value));
+                    break;
+                case AI_DOUBLE:
+                    Write<double>(&chunk, *((double*) value));
+                    break;
+                case AI_AISTRING:
+                    Write<aiString>(&chunk, *((aiString*) value));
+                    break;
+                case AI_AIVECTOR3D:
+                    Write<aiVector3D>(&chunk, *((aiVector3D*) value));
+                    break;
 #ifdef SWIG
-                    case FORCE_32BIT:
+                case FORCE_32BIT:
 #endif // SWIG
-                    default:
-                        break;
-				}
-			}
+                default:
+                    break;
+            }
         }
+    }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryTexture(IOStream * container, const aiTexture* tex)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AITEXTURE );
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryTexture(IOStream * container, const aiTexture* tex)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AITEXTURE );
 
-            Write<unsigned int>(&chunk,tex->mWidth);
-            Write<unsigned int>(&chunk,tex->mHeight);
-            chunk.Write( tex->achFormatHint, sizeof(char), 4 );
+        Write<unsigned int>(&chunk,tex->mWidth);
+        Write<unsigned int>(&chunk,tex->mHeight);
+        chunk.Write( tex->achFormatHint, sizeof(char), 4 );
 
-            if(!shortened) {
-                if (!tex->mHeight) {
-                    chunk.Write(tex->pcData,1,tex->mWidth);
-                }
-                else {
-                    chunk.Write(tex->pcData,1,tex->mWidth*tex->mHeight*4);
-                }
+        if(!shortened) {
+            if (!tex->mHeight) {
+                chunk.Write(tex->pcData,1,tex->mWidth);
+            }
+            else {
+                chunk.Write(tex->pcData,1,tex->mWidth*tex->mHeight*4);
             }
-
         }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryBone(IOStream * container, const aiBone* b)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIBONE );
+    }
 
-            Write<aiString>(&chunk,b->mName);
-            Write<unsigned int>(&chunk,b->mNumWeights);
-            Write<aiMatrix4x4>(&chunk,b->mOffsetMatrix);
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryBone(IOStream * container, const aiBone* b)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIBONE );
+
+        Write<aiString>(&chunk,b->mName);
+        Write<unsigned int>(&chunk,b->mNumWeights);
+        Write<aiMatrix4x4>(&chunk,b->mOffsetMatrix);
+
+        // for the moment we write dumb min/max values for the bones, too.
+        // maybe I'll add a better, hash-like solution later
+        if (shortened) {
+            WriteBounds(&chunk,b->mWeights,b->mNumWeights);
+        } // else write as usual
+        else WriteArray<aiVertexWeight>(&chunk,b->mWeights,b->mNumWeights);
+    }
 
-            // for the moment we write dumb min/max values for the bones, too.
-            // maybe I'll add a better, hash-like solution later
-            if (shortened) {
-                WriteBounds(&chunk,b->mWeights,b->mNumWeights);
-            } // else write as usual
-            else WriteArray<aiVertexWeight>(&chunk,b->mWeights,b->mNumWeights);
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryMesh(IOStream * container, const aiMesh* mesh)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMESH );
+
+        Write<unsigned int>(&chunk,mesh->mPrimitiveTypes);
+        Write<unsigned int>(&chunk,mesh->mNumVertices);
+        Write<unsigned int>(&chunk,mesh->mNumFaces);
+        Write<unsigned int>(&chunk,mesh->mNumBones);
+        Write<unsigned int>(&chunk,mesh->mMaterialIndex);
+
+        // first of all, write bits for all existent vertex components
+        unsigned int c = 0;
+        if (mesh->mVertices) {
+            c |= ASSBIN_MESH_HAS_POSITIONS;
         }
-
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryMesh(IOStream * container, const aiMesh* mesh)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMESH );
-
-            Write<unsigned int>(&chunk,mesh->mPrimitiveTypes);
-            Write<unsigned int>(&chunk,mesh->mNumVertices);
-            Write<unsigned int>(&chunk,mesh->mNumFaces);
-            Write<unsigned int>(&chunk,mesh->mNumBones);
-            Write<unsigned int>(&chunk,mesh->mMaterialIndex);
-
-            // first of all, write bits for all existent vertex components
-            unsigned int c = 0;
-            if (mesh->mVertices) {
-                c |= ASSBIN_MESH_HAS_POSITIONS;
-            }
-            if (mesh->mNormals) {
-                c |= ASSBIN_MESH_HAS_NORMALS;
-            }
-            if (mesh->mTangents && mesh->mBitangents) {
-                c |= ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS;
-            }
-            for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
-                if (!mesh->mTextureCoords[n]) {
-                    break;
-                }
-                c |= ASSBIN_MESH_HAS_TEXCOORD(n);
-            }
-            for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
-                if (!mesh->mColors[n]) {
-                    break;
-                }
-                c |= ASSBIN_MESH_HAS_COLOR(n);
-            }
-            Write<unsigned int>(&chunk,c);
-
-            aiVector3D minVec, maxVec;
-            if (mesh->mVertices) {
-                if (shortened) {
-                    WriteBounds(&chunk,mesh->mVertices,mesh->mNumVertices);
-                } // else write as usual
-                else WriteArray<aiVector3D>(&chunk,mesh->mVertices,mesh->mNumVertices);
-            }
-            if (mesh->mNormals) {
-                if (shortened) {
-                    WriteBounds(&chunk,mesh->mNormals,mesh->mNumVertices);
-                } // else write as usual
-                else WriteArray<aiVector3D>(&chunk,mesh->mNormals,mesh->mNumVertices);
+        if (mesh->mNormals) {
+            c |= ASSBIN_MESH_HAS_NORMALS;
+        }
+        if (mesh->mTangents && mesh->mBitangents) {
+            c |= ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS;
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
+            if (!mesh->mTextureCoords[n]) {
+                break;
             }
-            if (mesh->mTangents && mesh->mBitangents) {
-                if (shortened) {
-                    WriteBounds(&chunk,mesh->mTangents,mesh->mNumVertices);
-                    WriteBounds(&chunk,mesh->mBitangents,mesh->mNumVertices);
-                } // else write as usual
-                else {
-                    WriteArray<aiVector3D>(&chunk,mesh->mTangents,mesh->mNumVertices);
-                    WriteArray<aiVector3D>(&chunk,mesh->mBitangents,mesh->mNumVertices);
-                }
+            c |= ASSBIN_MESH_HAS_TEXCOORD(n);
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
+            if (!mesh->mColors[n]) {
+                break;
             }
-            for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
-                if (!mesh->mColors[n])
-                    break;
+            c |= ASSBIN_MESH_HAS_COLOR(n);
+        }
+        Write<unsigned int>(&chunk,c);
 
-                if (shortened) {
-                    WriteBounds(&chunk,mesh->mColors[n],mesh->mNumVertices);
-                } // else write as usual
-                else WriteArray<aiColor4D>(&chunk,mesh->mColors[n],mesh->mNumVertices);
+        aiVector3D minVec, maxVec;
+        if (mesh->mVertices) {
+            if (shortened) {
+                WriteBounds(&chunk,mesh->mVertices,mesh->mNumVertices);
+            } // else write as usual
+            else WriteArray<aiVector3D>(&chunk,mesh->mVertices,mesh->mNumVertices);
+        }
+        if (mesh->mNormals) {
+            if (shortened) {
+                WriteBounds(&chunk,mesh->mNormals,mesh->mNumVertices);
+            } // else write as usual
+            else WriteArray<aiVector3D>(&chunk,mesh->mNormals,mesh->mNumVertices);
+        }
+        if (mesh->mTangents && mesh->mBitangents) {
+            if (shortened) {
+                WriteBounds(&chunk,mesh->mTangents,mesh->mNumVertices);
+                WriteBounds(&chunk,mesh->mBitangents,mesh->mNumVertices);
+            } // else write as usual
+            else {
+                WriteArray<aiVector3D>(&chunk,mesh->mTangents,mesh->mNumVertices);
+                WriteArray<aiVector3D>(&chunk,mesh->mBitangents,mesh->mNumVertices);
             }
-            for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
-                if (!mesh->mTextureCoords[n])
-                    break;
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
+            if (!mesh->mColors[n])
+                break;
 
-                // write number of UV components
-                Write<unsigned int>(&chunk,mesh->mNumUVComponents[n]);
+            if (shortened) {
+                WriteBounds(&chunk,mesh->mColors[n],mesh->mNumVertices);
+            } // else write as usual
+            else WriteArray<aiColor4D>(&chunk,mesh->mColors[n],mesh->mNumVertices);
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
+            if (!mesh->mTextureCoords[n])
+                break;
 
-                if (shortened) {
-                    WriteBounds(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
-                } // else write as usual
-                else WriteArray<aiVector3D>(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
-            }
+            // write number of UV components
+            Write<unsigned int>(&chunk,mesh->mNumUVComponents[n]);
 
-            // write faces. There are no floating-point calculations involved
-            // in these, so we can write a simple hash over the face data
-            // to the dump file. We generate a single 32 Bit hash for 512 faces
-            // using Assimp's standard hashing function.
             if (shortened) {
-                unsigned int processed = 0;
-                for (unsigned int job;(job = std::min(mesh->mNumFaces-processed,512u));processed += job) {
-
-                    uint32_t hash = 0;
-                    for (unsigned int a = 0; a < job;++a) {
+                WriteBounds(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
+            } // else write as usual
+            else WriteArray<aiVector3D>(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
+        }
 
-                        const aiFace& f = mesh->mFaces[processed+a];
-                        uint32_t tmp = f.mNumIndices;
+        // write faces. There are no floating-point calculations involved
+        // in these, so we can write a simple hash over the face data
+        // to the dump file. We generate a single 32 Bit hash for 512 faces
+        // using Assimp's standard hashing function.
+        if (shortened) {
+            unsigned int processed = 0;
+            for (unsigned int job;(job = std::min(mesh->mNumFaces-processed,512u));processed += job) {
+
+                uint32_t hash = 0;
+                for (unsigned int a = 0; a < job;++a) {
+
+                    const aiFace& f = mesh->mFaces[processed+a];
+                    uint32_t tmp = f.mNumIndices;
+                    hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash);
+                    for (unsigned int i = 0; i < f.mNumIndices; ++i) {
+                        static_assert(AI_MAX_VERTICES <= 0xffffffff, "AI_MAX_VERTICES <= 0xffffffff");
+                        tmp = static_cast<uint32_t>( f.mIndices[i] );
                         hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash);
-                        for (unsigned int i = 0; i < f.mNumIndices; ++i) {
-                            static_assert(AI_MAX_VERTICES <= 0xffffffff, "AI_MAX_VERTICES <= 0xffffffff");
-                            tmp = static_cast<uint32_t>( f.mIndices[i] );
-                            hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash);
-                        }
                     }
-                    Write<unsigned int>(&chunk,hash);
                 }
+                Write<unsigned int>(&chunk,hash);
             }
-            else // else write as usual
-            {
-                // if there are less than 2^16 vertices, we can simply use 16 bit integers ...
-                for (unsigned int i = 0; i < mesh->mNumFaces;++i) {
-                    const aiFace& f = mesh->mFaces[i];
-
-                    static_assert(AI_MAX_FACE_INDICES <= 0xffff, "AI_MAX_FACE_INDICES <= 0xffff");
-                    Write<uint16_t>(&chunk,f.mNumIndices);
-
-                    for (unsigned int a = 0; a < f.mNumIndices;++a) {
-                        if (mesh->mNumVertices < (1u<<16)) {
-                            Write<uint16_t>(&chunk,f.mIndices[a]);
-                        }
-                        else Write<unsigned int>(&chunk,f.mIndices[a]);
+        }
+        else // else write as usual
+        {
+            // if there are less than 2^16 vertices, we can simply use 16 bit integers ...
+            for (unsigned int i = 0; i < mesh->mNumFaces;++i) {
+                const aiFace& f = mesh->mFaces[i];
+
+                static_assert(AI_MAX_FACE_INDICES <= 0xffff, "AI_MAX_FACE_INDICES <= 0xffff");
+                Write<uint16_t>(&chunk,f.mNumIndices);
+
+                for (unsigned int a = 0; a < f.mNumIndices;++a) {
+                    if (mesh->mNumVertices < (1u<<16)) {
+                        Write<uint16_t>(&chunk,f.mIndices[a]);
                     }
+                    else Write<unsigned int>(&chunk,f.mIndices[a]);
                 }
             }
+        }
 
-            // write bones
-            if (mesh->mNumBones) {
-                for (unsigned int a = 0; a < mesh->mNumBones;++a) {
-                    const aiBone* b = mesh->mBones[a];
-                    WriteBinaryBone(&chunk,b);
-                }
+        // write bones
+        if (mesh->mNumBones) {
+            for (unsigned int a = 0; a < mesh->mNumBones;++a) {
+                const aiBone* b = mesh->mBones[a];
+                WriteBinaryBone(&chunk,b);
             }
         }
+    }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryMaterialProperty(IOStream * container, const aiMaterialProperty* prop)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIALPROPERTY );
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryMaterialProperty(IOStream * container, const aiMaterialProperty* prop)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIALPROPERTY );
 
-            Write<aiString>(&chunk,prop->mKey);
-            Write<unsigned int>(&chunk,prop->mSemantic);
-            Write<unsigned int>(&chunk,prop->mIndex);
+        Write<aiString>(&chunk,prop->mKey);
+        Write<unsigned int>(&chunk,prop->mSemantic);
+        Write<unsigned int>(&chunk,prop->mIndex);
 
-            Write<unsigned int>(&chunk,prop->mDataLength);
-            Write<unsigned int>(&chunk,(unsigned int)prop->mType);
-            chunk.Write(prop->mData,1,prop->mDataLength);
-        }
+        Write<unsigned int>(&chunk,prop->mDataLength);
+        Write<unsigned int>(&chunk,(unsigned int)prop->mType);
+        chunk.Write(prop->mData,1,prop->mDataLength);
+    }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryMaterial(IOStream * container, const aiMaterial* mat)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIAL);
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryMaterial(IOStream * container, const aiMaterial* mat)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIAL);
 
-            Write<unsigned int>(&chunk,mat->mNumProperties);
-            for (unsigned int i = 0; i < mat->mNumProperties;++i) {
-                WriteBinaryMaterialProperty( &chunk, mat->mProperties[i]);
-            }
+        Write<unsigned int>(&chunk,mat->mNumProperties);
+        for (unsigned int i = 0; i < mat->mNumProperties;++i) {
+            WriteBinaryMaterialProperty( &chunk, mat->mProperties[i]);
         }
+    }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryNodeAnim(IOStream * container, const aiNodeAnim* nd)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODEANIM );
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryNodeAnim(IOStream * container, const aiNodeAnim* nd)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODEANIM );
 
-            Write<aiString>(&chunk,nd->mNodeName);
-            Write<unsigned int>(&chunk,nd->mNumPositionKeys);
-            Write<unsigned int>(&chunk,nd->mNumRotationKeys);
-            Write<unsigned int>(&chunk,nd->mNumScalingKeys);
-            Write<unsigned int>(&chunk,nd->mPreState);
-            Write<unsigned int>(&chunk,nd->mPostState);
+        Write<aiString>(&chunk,nd->mNodeName);
+        Write<unsigned int>(&chunk,nd->mNumPositionKeys);
+        Write<unsigned int>(&chunk,nd->mNumRotationKeys);
+        Write<unsigned int>(&chunk,nd->mNumScalingKeys);
+        Write<unsigned int>(&chunk,nd->mPreState);
+        Write<unsigned int>(&chunk,nd->mPostState);
 
-            if (nd->mPositionKeys) {
-                if (shortened) {
-                    WriteBounds(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
+        if (nd->mPositionKeys) {
+            if (shortened) {
+                WriteBounds(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
 
-                } // else write as usual
-                else WriteArray<aiVectorKey>(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
-            }
-            if (nd->mRotationKeys) {
-                if (shortened) {
-                    WriteBounds(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
+            } // else write as usual
+            else WriteArray<aiVectorKey>(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
+        }
+        if (nd->mRotationKeys) {
+            if (shortened) {
+                WriteBounds(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
 
-                } // else write as usual
-                else WriteArray<aiQuatKey>(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
-            }
-            if (nd->mScalingKeys) {
-                if (shortened) {
-                    WriteBounds(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
+            } // else write as usual
+            else WriteArray<aiQuatKey>(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
+        }
+        if (nd->mScalingKeys) {
+            if (shortened) {
+                WriteBounds(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
 
-                } // else write as usual
-                else WriteArray<aiVectorKey>(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
-            }
+            } // else write as usual
+            else WriteArray<aiVectorKey>(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
         }
+    }
 
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryAnim( IOStream * container, const aiAnimation* anim )
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIANIMATION );
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryAnim( IOStream * container, const aiAnimation* anim )
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIANIMATION );
 
-            Write<aiString>(&chunk,anim->mName);
-            Write<double>(&chunk,anim->mDuration);
-            Write<double>(&chunk,anim->mTicksPerSecond);
-            Write<unsigned int>(&chunk,anim->mNumChannels);
+        Write<aiString>(&chunk,anim->mName);
+        Write<double>(&chunk,anim->mDuration);
+        Write<double>(&chunk,anim->mTicksPerSecond);
+        Write<unsigned int>(&chunk,anim->mNumChannels);
 
-            for (unsigned int a = 0; a < anim->mNumChannels;++a) {
-                const aiNodeAnim* nd = anim->mChannels[a];
-                WriteBinaryNodeAnim(&chunk,nd);
-            }
+        for (unsigned int a = 0; a < anim->mNumChannels;++a) {
+            const aiNodeAnim* nd = anim->mChannels[a];
+            WriteBinaryNodeAnim(&chunk,nd);
         }
+    }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryLight( IOStream * container, const aiLight* l )
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AILIGHT );
-
-            Write<aiString>(&chunk,l->mName);
-            Write<unsigned int>(&chunk,l->mType);
-
-            if (l->mType != aiLightSource_DIRECTIONAL) {
-                Write<float>(&chunk,l->mAttenuationConstant);
-                Write<float>(&chunk,l->mAttenuationLinear);
-                Write<float>(&chunk,l->mAttenuationQuadratic);
-            }
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryLight( IOStream * container, const aiLight* l )
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AILIGHT );
 
-            Write<aiColor3D>(&chunk,l->mColorDiffuse);
-            Write<aiColor3D>(&chunk,l->mColorSpecular);
-            Write<aiColor3D>(&chunk,l->mColorAmbient);
-
-            if (l->mType == aiLightSource_SPOT) {
-                Write<float>(&chunk,l->mAngleInnerCone);
-                Write<float>(&chunk,l->mAngleOuterCone);
-            }
+        Write<aiString>(&chunk,l->mName);
+        Write<unsigned int>(&chunk,l->mType);
 
+        if (l->mType != aiLightSource_DIRECTIONAL) {
+            Write<float>(&chunk,l->mAttenuationConstant);
+            Write<float>(&chunk,l->mAttenuationLinear);
+            Write<float>(&chunk,l->mAttenuationQuadratic);
         }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryCamera( IOStream * container, const aiCamera* cam )
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AICAMERA );
+        Write<aiColor3D>(&chunk,l->mColorDiffuse);
+        Write<aiColor3D>(&chunk,l->mColorSpecular);
+        Write<aiColor3D>(&chunk,l->mColorAmbient);
 
-            Write<aiString>(&chunk,cam->mName);
-            Write<aiVector3D>(&chunk,cam->mPosition);
-            Write<aiVector3D>(&chunk,cam->mLookAt);
-            Write<aiVector3D>(&chunk,cam->mUp);
-            Write<float>(&chunk,cam->mHorizontalFOV);
-            Write<float>(&chunk,cam->mClipPlaneNear);
-            Write<float>(&chunk,cam->mClipPlaneFar);
-            Write<float>(&chunk,cam->mAspect);
+        if (l->mType == aiLightSource_SPOT) {
+            Write<float>(&chunk,l->mAngleInnerCone);
+            Write<float>(&chunk,l->mAngleOuterCone);
         }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryScene( IOStream * container, const aiScene* scene)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AISCENE );
-
-            // basic scene information
-            Write<unsigned int>(&chunk,scene->mFlags);
-            Write<unsigned int>(&chunk,scene->mNumMeshes);
-            Write<unsigned int>(&chunk,scene->mNumMaterials);
-            Write<unsigned int>(&chunk,scene->mNumAnimations);
-            Write<unsigned int>(&chunk,scene->mNumTextures);
-            Write<unsigned int>(&chunk,scene->mNumLights);
-            Write<unsigned int>(&chunk,scene->mNumCameras);
-
-            // write node graph
-            WriteBinaryNode( &chunk, scene->mRootNode );
-
-            // write all meshes
-            for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
-                const aiMesh* mesh = scene->mMeshes[i];
-                WriteBinaryMesh( &chunk,mesh);
-            }
+    }
 
-            // write materials
-            for (unsigned int i = 0; i< scene->mNumMaterials; ++i) {
-                const aiMaterial* mat = scene->mMaterials[i];
-                WriteBinaryMaterial(&chunk,mat);
-            }
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryCamera( IOStream * container, const aiCamera* cam )
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AICAMERA );
+
+        Write<aiString>(&chunk,cam->mName);
+        Write<aiVector3D>(&chunk,cam->mPosition);
+        Write<aiVector3D>(&chunk,cam->mLookAt);
+        Write<aiVector3D>(&chunk,cam->mUp);
+        Write<float>(&chunk,cam->mHorizontalFOV);
+        Write<float>(&chunk,cam->mClipPlaneNear);
+        Write<float>(&chunk,cam->mClipPlaneFar);
+        Write<float>(&chunk,cam->mAspect);
+    }
 
-            // write all animations
-            for (unsigned int i = 0; i < scene->mNumAnimations;++i) {
-                const aiAnimation* anim = scene->mAnimations[i];
-                WriteBinaryAnim(&chunk,anim);
-            }
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryScene( IOStream * container, const aiScene* scene)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AISCENE );
+
+        // basic scene information
+        Write<unsigned int>(&chunk,scene->mFlags);
+        Write<unsigned int>(&chunk,scene->mNumMeshes);
+        Write<unsigned int>(&chunk,scene->mNumMaterials);
+        Write<unsigned int>(&chunk,scene->mNumAnimations);
+        Write<unsigned int>(&chunk,scene->mNumTextures);
+        Write<unsigned int>(&chunk,scene->mNumLights);
+        Write<unsigned int>(&chunk,scene->mNumCameras);
+
+        // write node graph
+        WriteBinaryNode( &chunk, scene->mRootNode );
+
+        // write all meshes
+        for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
+            const aiMesh* mesh = scene->mMeshes[i];
+            WriteBinaryMesh( &chunk,mesh);
+        }
 
+        // write materials
+        for (unsigned int i = 0; i< scene->mNumMaterials; ++i) {
+            const aiMaterial* mat = scene->mMaterials[i];
+            WriteBinaryMaterial(&chunk,mat);
+        }
 
-            // write all textures
-            for (unsigned int i = 0; i < scene->mNumTextures;++i) {
-                const aiTexture* mesh = scene->mTextures[i];
-                WriteBinaryTexture(&chunk,mesh);
-            }
+        // write all animations
+        for (unsigned int i = 0; i < scene->mNumAnimations;++i) {
+            const aiAnimation* anim = scene->mAnimations[i];
+            WriteBinaryAnim(&chunk,anim);
+        }
 
-            // write lights
-            for (unsigned int i = 0; i < scene->mNumLights;++i) {
-                const aiLight* l = scene->mLights[i];
-                WriteBinaryLight(&chunk,l);
-            }
 
-            // write cameras
-            for (unsigned int i = 0; i < scene->mNumCameras;++i) {
-                const aiCamera* cam = scene->mCameras[i];
-                WriteBinaryCamera(&chunk,cam);
-            }
+        // write all textures
+        for (unsigned int i = 0; i < scene->mNumTextures;++i) {
+            const aiTexture* mesh = scene->mTextures[i];
+            WriteBinaryTexture(&chunk,mesh);
+        }
 
+        // write lights
+        for (unsigned int i = 0; i < scene->mNumLights;++i) {
+            const aiLight* l = scene->mLights[i];
+            WriteBinaryLight(&chunk,l);
         }
 
-    public:
-        AssbinExport()
-            : shortened(false), compressed(false) // temporary settings until properties are introduced for exporters
-        {
+        // write cameras
+        for (unsigned int i = 0; i < scene->mNumCameras;++i) {
+            const aiCamera* cam = scene->mCameras[i];
+            WriteBinaryCamera(&chunk,cam);
         }
 
-        // -----------------------------------------------------------------------------------
-        // Write a binary model dump
-        void WriteBinaryDump(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene)
-        {
-            IOStream * out = pIOSystem->Open( pFile, "wb" );
-            if (!out) return;
+    }
+
+public:
+    AssbinExport()
+        : shortened(false), compressed(false) // temporary settings until properties are introduced for exporters
+    {
+    }
+
+    // -----------------------------------------------------------------------------------
+    // Write a binary model dump
+    void WriteBinaryDump(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene)
+    {
+        IOStream * out = pIOSystem->Open( pFile, "wb" );
+        if (!out) return;
 
-            time_t tt = time(NULL);
-            tm* p     = gmtime(&tt);
+        time_t tt = time(NULL);
+        tm* p     = gmtime(&tt);
 
-            // header
-            char s[64];
-            memset( s, 0, 64 );
+        // header
+        char s[64];
+        memset( s, 0, 64 );
 #if _MSC_VER >= 1400
-            sprintf_s(s,"ASSIMP.binary-dump.%s",asctime(p));
+        sprintf_s(s,"ASSIMP.binary-dump.%s",asctime(p));
 #else
-            ai_snprintf(s,64,"ASSIMP.binary-dump.%s",asctime(p));
+        ai_snprintf(s,64,"ASSIMP.binary-dump.%s",asctime(p));
 #endif
-            out->Write( s, 44, 1 );
-            // == 44 bytes
-
-            Write<unsigned int>( out, ASSBIN_VERSION_MAJOR );
-            Write<unsigned int>( out, ASSBIN_VERSION_MINOR );
-            Write<unsigned int>( out, aiGetVersionRevision() );
-            Write<unsigned int>( out, aiGetCompileFlags() );
-            Write<uint16_t>( out, shortened );
-            Write<uint16_t>( out, compressed );
-            // ==  20 bytes
-
-            char buff[256];
-            strncpy(buff,pFile,256);
-            out->Write(buff,sizeof(char),256);
-
-            char cmd[] = "\0";
-            strncpy(buff,cmd,128);
-            out->Write(buff,sizeof(char),128);
-
-            // leave 64 bytes free for future extensions
-            memset(buff,0xcd,64);
-            out->Write(buff,sizeof(char),64);
-            // == 435 bytes
-
-            // ==== total header size: 512 bytes
-            ai_assert( out->Tell() == ASSBIN_HEADER_LENGTH );
-
-            // Up to here the data is uncompressed. For compressed files, the rest
-            // is compressed using standard DEFLATE from zlib.
-            if (compressed)
-            {
-                AssbinChunkWriter uncompressedStream( NULL, 0 );
-                WriteBinaryScene( &uncompressedStream, pScene );
-
-                uLongf uncompressedSize = static_cast<uLongf>(uncompressedStream.Tell());
-                uLongf compressedSize = (uLongf)(uncompressedStream.Tell() * 1.001 + 12.);
-                uint8_t* compressedBuffer = new uint8_t[ compressedSize ];
-
-                compress2( compressedBuffer, &compressedSize, (const Bytef*)uncompressedStream.GetBufferPointer(), uncompressedSize, 9 );
-
-                out->Write( &uncompressedSize, sizeof(uint32_t), 1 );
-                out->Write( compressedBuffer, sizeof(char), compressedSize );
-
-                delete[] compressedBuffer;
-            }
-            else
-            {
-                WriteBinaryScene( out, pScene );
-            }
+        out->Write( s, 44, 1 );
+        // == 44 bytes
+
+        Write<unsigned int>( out, ASSBIN_VERSION_MAJOR );
+        Write<unsigned int>( out, ASSBIN_VERSION_MINOR );
+        Write<unsigned int>( out, aiGetVersionRevision() );
+        Write<unsigned int>( out, aiGetCompileFlags() );
+        Write<uint16_t>( out, shortened );
+        Write<uint16_t>( out, compressed );
+        // ==  20 bytes
+
+        char buff[256];
+        strncpy(buff,pFile,256);
+        out->Write(buff,sizeof(char),256);
+
+        char cmd[] = "\0";
+        strncpy(buff,cmd,128);
+        out->Write(buff,sizeof(char),128);
+
+        // leave 64 bytes free for future extensions
+        memset(buff,0xcd,64);
+        out->Write(buff,sizeof(char),64);
+        // == 435 bytes
+
+        // ==== total header size: 512 bytes
+        ai_assert( out->Tell() == ASSBIN_HEADER_LENGTH );
+
+        // Up to here the data is uncompressed. For compressed files, the rest
+        // is compressed using standard DEFLATE from zlib.
+        if (compressed)
+        {
+            AssbinChunkWriter uncompressedStream( NULL, 0 );
+            WriteBinaryScene( &uncompressedStream, pScene );
+
+            uLongf uncompressedSize = static_cast<uLongf>(uncompressedStream.Tell());
+            uLongf compressedSize = (uLongf)(uncompressedStream.Tell() * 1.001 + 12.);
+            uint8_t* compressedBuffer = new uint8_t[ compressedSize ];
+
+            compress2( compressedBuffer, &compressedSize, (const Bytef*)uncompressedStream.GetBufferPointer(), uncompressedSize, 9 );
 
-            pIOSystem->Close( out );
+            out->Write( &uncompressedSize, sizeof(uint32_t), 1 );
+            out->Write( compressedBuffer, sizeof(char), compressedSize );
+
+            delete[] compressedBuffer;
+        }
+        else
+        {
+            WriteBinaryScene( out, pScene );
         }
-    };
 
-void ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
-{
+        pIOSystem->Close( out );
+    }
+};
+
+void ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/) {
     AssbinExport exporter;
     exporter.WriteBinaryDump( pFile, pIOSystem, pScene );
 }

code/AssbinExporter.h

@@ -46,6 +46,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_ASSBINEXPORTER_H_INC
 #define AI_ASSBINEXPORTER_H_INC
 
+#include <assimp/defs.h>
+
 // nothing really needed here - reserved for future use like properties
+namespace Assimp {
+
+void ASSIMP_API ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/);
+
+}
 
-#endif
+#endif // AI_ASSBINEXPORTER_H_INC

code/AssbinLoader.cpp

@@ -79,16 +79,17 @@ static const aiImporterDesc desc = {
     "assbin"
 };
 
-const aiImporterDesc* AssbinImporter::GetInfo() const
-{
+// -----------------------------------------------------------------------------------
+const aiImporterDesc* AssbinImporter::GetInfo() const {
     return &desc;
 }
 
-bool AssbinImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/ ) const
-{
+// -----------------------------------------------------------------------------------
+bool AssbinImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/ ) const {
     IOStream * in = pIOHandler->Open(pFile);
-    if (!in)
+    if (nullptr == in) {
         return false;
+    }
 
     char s[32];
     in->Read( s, sizeof(char), 32 );
@@ -98,17 +99,17 @@ bool AssbinImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bo
     return strncmp( s, "ASSIMP.binary-dump.", 19 ) == 0;
 }
 
+// -----------------------------------------------------------------------------------
 template <typename T>
-T Read(IOStream * stream)
-{
+T Read(IOStream * stream) {
     T t;
     stream->Read( &t, sizeof(T), 1 );
     return t;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiVector3D Read<aiVector3D>(IOStream * stream)
-{
+aiVector3D Read<aiVector3D>(IOStream * stream) {
     aiVector3D v;
     v.x = Read<float>(stream);
     v.y = Read<float>(stream);
@@ -116,9 +117,9 @@ aiVector3D Read<aiVector3D>(IOStream * stream)
     return v;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiColor4D Read<aiColor4D>(IOStream * stream)
-{
+aiColor4D Read<aiColor4D>(IOStream * stream) {
     aiColor4D c;
     c.r = Read<float>(stream);
     c.g = Read<float>(stream);
@@ -127,9 +128,9 @@ aiColor4D Read<aiColor4D>(IOStream * stream)
     return c;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiQuaternion Read<aiQuaternion>(IOStream * stream)
-{
+aiQuaternion Read<aiQuaternion>(IOStream * stream) {
     aiQuaternion v;
     v.w = Read<float>(stream);
     v.x = Read<float>(stream);
@@ -138,9 +139,9 @@ aiQuaternion Read<aiQuaternion>(IOStream * stream)
     return v;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiString Read<aiString>(IOStream * stream)
-{
+aiString Read<aiString>(IOStream * stream) {
     aiString s;
     stream->Read(&s.length,4,1);
     stream->Read(s.data,s.length,1);
@@ -148,18 +149,18 @@ aiString Read<aiString>(IOStream * stream)
     return s;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiVertexWeight Read<aiVertexWeight>(IOStream * stream)
-{
+aiVertexWeight Read<aiVertexWeight>(IOStream * stream) {
     aiVertexWeight w;
     w.mVertexId = Read<unsigned int>(stream);
     w.mWeight = Read<float>(stream);
     return w;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiMatrix4x4 Read<aiMatrix4x4>(IOStream * stream)
-{
+aiMatrix4x4 Read<aiMatrix4x4>(IOStream * stream) {
     aiMatrix4x4 m;
     for (unsigned int i = 0; i < 4;++i) {
         for (unsigned int i2 = 0; i2 < 4;++i2) {
@@ -169,36 +170,43 @@ aiMatrix4x4 Read<aiMatrix4x4>(IOStream * stream)
     return m;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiVectorKey Read<aiVectorKey>(IOStream * stream)
-{
+aiVectorKey Read<aiVectorKey>(IOStream * stream) {
     aiVectorKey v;
     v.mTime = Read<double>(stream);
     v.mValue = Read<aiVector3D>(stream);
     return v;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiQuatKey Read<aiQuatKey>(IOStream * stream)
-{
+aiQuatKey Read<aiQuatKey>(IOStream * stream) {
     aiQuatKey v;
     v.mTime = Read<double>(stream);
     v.mValue = Read<aiQuaternion>(stream);
     return v;
 }
 
+// -----------------------------------------------------------------------------------
 template <typename T>
-void ReadArray(IOStream * stream, T * out, unsigned int size)
-{
-    for (unsigned int i=0; i<size; i++) out[i] = Read<T>(stream);
+void ReadArray( IOStream *stream, T * out, unsigned int size) {
+    ai_assert( nullptr != stream );
+    ai_assert( nullptr != out );
+
+    for (unsigned int i=0; i<size; i++) {
+        out[i] = Read<T>(stream);
+    }
 }
 
-template <typename T> void ReadBounds( IOStream * stream, T* /*p*/, unsigned int n )
-{
+// -----------------------------------------------------------------------------------
+template <typename T>
+void ReadBounds( IOStream * stream, T* /*p*/, unsigned int n ) {
     // not sure what to do here, the data isn't really useful.
     stream->Seek( sizeof(T) * n, aiOrigin_CUR );
 }
 
+// -----------------------------------------------------------------------------------
 void AssbinImporter::ReadBinaryNode( IOStream * stream, aiNode** node, aiNode* parent ) {
     uint32_t chunkID = Read<uint32_t>(stream);
     (void)(chunkID);
@@ -273,8 +281,7 @@ void AssbinImporter::ReadBinaryNode( IOStream * stream, aiNode** node, aiNode* p
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b )
-{
+void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b ) {
     uint32_t chunkID = Read<uint32_t>(stream);
     (void)(chunkID);
     ai_assert(chunkID == ASSBIN_CHUNK_AIBONE);
@@ -286,20 +293,22 @@ void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b )
 
     // for the moment we write dumb min/max values for the bones, too.
     // maybe I'll add a better, hash-like solution later
-    if (shortened)
-    {
+    if (shortened) {
         ReadBounds(stream,b->mWeights,b->mNumWeights);
-    } // else write as usual
-    else
-    {
+    } else {
+        // else write as usual
         b->mWeights = new aiVertexWeight[b->mNumWeights];
         ReadArray<aiVertexWeight>(stream,b->mWeights,b->mNumWeights);
     }
 }
 
+// -----------------------------------------------------------------------------------
+static bool fitsIntoUI16(unsigned int mNumVertices) {
+    return ( mNumVertices < (1u<<16) );
+}
 
-void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
-{
+// -----------------------------------------------------------------------------------
+void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh ) {
     uint32_t chunkID = Read<uint32_t>(stream);
     (void)(chunkID);
     ai_assert(chunkID == ASSBIN_CHUNK_AIMESH);
@@ -314,70 +323,61 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
     // first of all, write bits for all existent vertex components
     unsigned int c = Read<unsigned int>(stream);
 
-    if (c & ASSBIN_MESH_HAS_POSITIONS)
-    {
+    if (c & ASSBIN_MESH_HAS_POSITIONS) {
         if (shortened) {
             ReadBounds(stream,mesh->mVertices,mesh->mNumVertices);
-        } // else write as usual
-        else
-        {
+        }  else {
+            // else write as usual
             mesh->mVertices = new aiVector3D[mesh->mNumVertices];
             ReadArray<aiVector3D>(stream,mesh->mVertices,mesh->mNumVertices);
         }
     }
-    if (c & ASSBIN_MESH_HAS_NORMALS)
-    {
+    if (c & ASSBIN_MESH_HAS_NORMALS) {
         if (shortened) {
             ReadBounds(stream,mesh->mNormals,mesh->mNumVertices);
-        } // else write as usual
-        else
-        {
+        }  else {
+            // else write as usual
             mesh->mNormals = new aiVector3D[mesh->mNumVertices];
             ReadArray<aiVector3D>(stream,mesh->mNormals,mesh->mNumVertices);
         }
     }
-    if (c & ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS)
-    {
+    if (c & ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS) {
         if (shortened) {
             ReadBounds(stream,mesh->mTangents,mesh->mNumVertices);
             ReadBounds(stream,mesh->mBitangents,mesh->mNumVertices);
-        } // else write as usual
-        else
-        {
+        }  else {
+            // else write as usual
             mesh->mTangents = new aiVector3D[mesh->mNumVertices];
             ReadArray<aiVector3D>(stream,mesh->mTangents,mesh->mNumVertices);
             mesh->mBitangents = new aiVector3D[mesh->mNumVertices];
             ReadArray<aiVector3D>(stream,mesh->mBitangents,mesh->mNumVertices);
         }
     }
-    for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n)
-    {
-        if (!(c & ASSBIN_MESH_HAS_COLOR(n)))
+    for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
+        if (!(c & ASSBIN_MESH_HAS_COLOR(n))) {
             break;
+        }
 
-        if (shortened)
-        {
+        if (shortened) {
             ReadBounds(stream,mesh->mColors[n],mesh->mNumVertices);
-        } // else write as usual
-        else
-        {
+        }  else {
+            // else write as usual
             mesh->mColors[n] = new aiColor4D[mesh->mNumVertices];
             ReadArray<aiColor4D>(stream,mesh->mColors[n],mesh->mNumVertices);
         }
     }
-    for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n)
-    {
-        if (!(c & ASSBIN_MESH_HAS_TEXCOORD(n)))
+    for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
+        if (!(c & ASSBIN_MESH_HAS_TEXCOORD(n))) {
             break;
+        }
 
         // write number of UV components
         mesh->mNumUVComponents[n] = Read<unsigned int>(stream);
 
         if (shortened) {
             ReadBounds(stream,mesh->mTextureCoords[n],mesh->mNumVertices);
-        } // else write as usual
-        else
-        {
+        }  else {
+            // else write as usual
             mesh->mTextureCoords[n] = new aiVector3D[mesh->mNumVertices];
             ReadArray<aiVector3D>(stream,mesh->mTextureCoords[n],mesh->mNumVertices);
         }
@@ -389,9 +389,8 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
     // using Assimp's standard hashing function.
     if (shortened) {
         Read<unsigned int>(stream);
-    }
-    else // else write as usual
-    {
+    } else  {
+        // else write as usual
         // if there are less than 2^16 vertices, we can simply use 16 bit integers ...
         mesh->mFaces = new aiFace[mesh->mNumFaces];
         for (unsigned int i = 0; i < mesh->mNumFaces;++i) {
@@ -402,12 +401,10 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
             f.mIndices = new unsigned int[f.mNumIndices];
 
             for (unsigned int a = 0; a < f.mNumIndices;++a) {
-                if (mesh->mNumVertices < (1u<<16))
-                {
+                // Check if unsigned  short ( 16 bit  ) are big enought for the indices
+                if ( fitsIntoUI16( mesh->mNumVertices ) ) {
                     f.mIndices[a] = Read<uint16_t>(stream);
-                }
-                else
-                {
+                } else {
                     f.mIndices[a] = Read<unsigned int>(stream);
                 }
             }
@@ -424,8 +421,8 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
     }
 }
 
-void AssbinImporter::ReadBinaryMaterialProperty(IOStream * stream, aiMaterialProperty* prop)
-{
+// -----------------------------------------------------------------------------------
+void AssbinImporter::ReadBinaryMaterialProperty(IOStream * stream, aiMaterialProperty* prop) {
     uint32_t chunkID = Read<uint32_t>(stream);
     (void)(chunkID);
     ai_assert(chunkID == ASSBIN_CHUNK_AIMATERIALPROPERTY);
@@ -442,8 +439,7 @@ void AssbinImporter::ReadBinaryMaterialProperty(IOStream * stream, aiMaterialPro
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryMaterial(IOStream * stream, aiMaterial* mat)
-{
+void AssbinImporter::ReadBinaryMaterial(IOStream * stream, aiMaterial* mat) {
     uint32_t chunkID = Read<uint32_t>(stream);
     (void)(chunkID);
     ai_assert(chunkID == ASSBIN_CHUNK_AIMATERIAL);
@@ -465,8 +461,7 @@ void AssbinImporter::ReadBinaryMaterial(IOStream * stream, aiMaterial* mat)
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd)
-{
+void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd) {
     uint32_t chunkID = Read<uint32_t>(stream);
     (void)(chunkID);
     ai_assert(chunkID == ASSBIN_CHUNK_AINODEANIM);
@@ -493,9 +488,8 @@ void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd)
         if (shortened) {
             ReadBounds(stream,nd->mRotationKeys,nd->mNumRotationKeys);
 
-        } // else write as usual
-        else
-        {
+        }  else {
+            // else write as usual
             nd->mRotationKeys = new aiQuatKey[nd->mNumRotationKeys];
             ReadArray<aiQuatKey>(stream,nd->mRotationKeys,nd->mNumRotationKeys);
         }
@@ -504,19 +498,16 @@ void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd)
         if (shortened) {
             ReadBounds(stream,nd->mScalingKeys,nd->mNumScalingKeys);
 
-        } // else write as usual
-        else
-        {
+        }  else {
+            // else write as usual
             nd->mScalingKeys = new aiVectorKey[nd->mNumScalingKeys];
             ReadArray<aiVectorKey>(stream,nd->mScalingKeys,nd->mNumScalingKeys);
         }
     }
 }
 
-
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim )
-{
+void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim ) {
     uint32_t chunkID = Read<uint32_t>(stream);
     (void)(chunkID);
     ai_assert(chunkID == ASSBIN_CHUNK_AIANIMATION);
@@ -527,8 +518,7 @@ void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim )
     anim->mTicksPerSecond = Read<double> (stream);
     anim->mNumChannels = Read<unsigned int>(stream);
 
-    if (anim->mNumChannels)
-    {
+    if (anim->mNumChannels) {
         anim->mChannels = new aiNodeAnim*[ anim->mNumChannels ];
         for (unsigned int a = 0; a < anim->mNumChannels;++a) {
             anim->mChannels[a] = new aiNodeAnim();
@@ -537,8 +527,8 @@ void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim )
     }
 }
 
-void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex)
-{
+// -----------------------------------------------------------------------------------
+void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex) {
     uint32_t chunkID = Read<uint32_t>(stream);
     (void)(chunkID);
     ai_assert(chunkID == ASSBIN_CHUNK_AITEXTURE);
@@ -552,18 +542,15 @@ void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex)
         if (!tex->mHeight) {
             tex->pcData = new aiTexel[ tex->mWidth ];
             stream->Read(tex->pcData,1,tex->mWidth);
-        }
-        else {
+        } else {
             tex->pcData = new aiTexel[ tex->mWidth*tex->mHeight ];
             stream->Read(tex->pcData,1,tex->mWidth*tex->mHeight*4);
         }
     }
-
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryLight( IOStream * stream, aiLight* l )
-{
+void AssbinImporter::ReadBinaryLight( IOStream * stream, aiLight* l ) {
     uint32_t chunkID = Read<uint32_t>(stream);
     (void)(chunkID);
     ai_assert(chunkID == ASSBIN_CHUNK_AILIGHT);
@@ -586,12 +573,10 @@ void AssbinImporter::ReadBinaryLight( IOStream * stream, aiLight* l )
         l->mAngleInnerCone = Read<float>(stream);
         l->mAngleOuterCone = Read<float>(stream);
     }
-
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam )
-{
+void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam ) {
     uint32_t chunkID = Read<uint32_t>(stream);
     (void)(chunkID);
     ai_assert(chunkID == ASSBIN_CHUNK_AICAMERA);
@@ -607,8 +592,8 @@ void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam )
     cam->mAspect = Read<float>(stream);
 }
 
-void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
-{
+// -----------------------------------------------------------------------------------
+void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene ) {
     uint32_t chunkID = Read<uint32_t>(stream);
     (void)(chunkID);
     ai_assert(chunkID == ASSBIN_CHUNK_AISCENE);
@@ -623,12 +608,11 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
     scene->mNumCameras    = Read<unsigned int>(stream);
 
     // Read node graph
-    scene->mRootNode = new aiNode[1];
+    //scene->mRootNode = new aiNode[1];
     ReadBinaryNode( stream, &scene->mRootNode, (aiNode*)NULL );
 
     // Read all meshes
-    if (scene->mNumMeshes)
-    {
+    if (scene->mNumMeshes) {
         scene->mMeshes = new aiMesh*[scene->mNumMeshes];
         for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
             scene->mMeshes[i] = new aiMesh();
@@ -637,8 +621,7 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
     }
 
     // Read materials
-    if (scene->mNumMaterials)
-    {
+    if (scene->mNumMaterials) {
         scene->mMaterials = new aiMaterial*[scene->mNumMaterials];
         for (unsigned int i = 0; i< scene->mNumMaterials; ++i) {
             scene->mMaterials[i] = new aiMaterial();
@@ -647,8 +630,7 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
     }
 
     // Read all animations
-    if (scene->mNumAnimations)
-    {
+    if (scene->mNumAnimations) {
         scene->mAnimations = new aiAnimation*[scene->mNumAnimations];
         for (unsigned int i = 0; i < scene->mNumAnimations;++i) {
             scene->mAnimations[i] = new aiAnimation();
@@ -657,8 +639,7 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
     }
 
     // Read all textures
-    if (scene->mNumTextures)
-    {
+    if (scene->mNumTextures) {
         scene->mTextures = new aiTexture*[scene->mNumTextures];
         for (unsigned int i = 0; i < scene->mNumTextures;++i) {
             scene->mTextures[i] = new aiTexture();
@@ -667,8 +648,7 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
     }
 
     // Read lights
-    if (scene->mNumLights)
-    {
+    if (scene->mNumLights) {
         scene->mLights = new aiLight*[scene->mNumLights];
         for (unsigned int i = 0; i < scene->mNumLights;++i) {
             scene->mLights[i] = new aiLight();
@@ -677,8 +657,7 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
     }
 
     // Read cameras
-    if (scene->mNumCameras)
-    {
+    if (scene->mNumCameras) {
         scene->mCameras = new aiCamera*[scene->mNumCameras];
         for (unsigned int i = 0; i < scene->mNumCameras;++i) {
             scene->mCameras[i] = new aiCamera();
@@ -688,16 +667,22 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
 
 }
 
-void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler )
-{
+// -----------------------------------------------------------------------------------
+void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler ) {
     IOStream * stream = pIOHandler->Open(pFile,"rb");
-    if (!stream)
+    if (nullptr == stream) {
         return;
+    }
 
-    stream->Seek( 44, aiOrigin_CUR ); // signature
+    // signature
+    stream->Seek( 44, aiOrigin_CUR ); 
+
+    unsigned int versionMajor = Read<unsigned int>(stream);
+    unsigned int versionMinor = Read<unsigned int>(stream);
+    if (versionMinor != ASSBIN_VERSION_MINOR || versionMajor != ASSBIN_VERSION_MAJOR) {
+        throw DeadlyImportError( "Invalid version, data format not compatible!" );
+    }
 
-    /*unsigned int versionMajor =*/ Read<unsigned int>(stream);
-    /*unsigned int versionMinor =*/ Read<unsigned int>(stream);
     /*unsigned int versionRevision =*/ Read<unsigned int>(stream);
     /*unsigned int compileFlags =*/ Read<unsigned int>(stream);
 
@@ -711,8 +696,7 @@ void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
     stream->Seek( 128, aiOrigin_CUR ); // options
     stream->Seek( 64, aiOrigin_CUR ); // padding
 
-    if (compressed)
-    {
+    if (compressed) {
         uLongf uncompressedSize = Read<uint32_t>(stream);
         uLongf compressedSize = static_cast<uLongf>(stream->FileSize() - stream->Tell());
 
@@ -729,9 +713,7 @@ void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
 
         delete[] uncompressedData;
         delete[] compressedData;
-    }
-    else
-    {
+    } else {
         ReadBinaryScene(stream,pScene);
     }
 

code/AssbinLoader.h

@@ -70,32 +70,33 @@ namespace Assimp    {
 class AssbinImporter : public BaseImporter
 {
 private:
-  bool shortened;
-  bool compressed;
+    bool shortened;
+    bool compressed;
 
 public:
-  virtual bool CanRead(
-    const std::string& pFile,
-    IOSystem* pIOHandler,
-    bool checkSig
+    virtual bool CanRead(
+        const std::string& pFile,
+        IOSystem* pIOHandler,
+        bool checkSig
     ) const;
-  virtual const aiImporterDesc* GetInfo() const;
-  virtual void InternReadFile(
+    virtual const aiImporterDesc* GetInfo() const;
+    virtual void InternReadFile(
     const std::string& pFile,
-    aiScene* pScene,
-    IOSystem* pIOHandler
+        aiScene* pScene,
+        IOSystem* pIOHandler
     );
-  void ReadBinaryScene( IOStream * stream, aiScene* pScene );
-  void ReadBinaryNode( IOStream * stream, aiNode** mRootNode, aiNode* parent );
-  void ReadBinaryMesh( IOStream * stream, aiMesh* mesh );
-  void ReadBinaryBone( IOStream * stream, aiBone* bone );
-  void ReadBinaryMaterial(IOStream * stream, aiMaterial* mat);
-  void ReadBinaryMaterialProperty(IOStream * stream, aiMaterialProperty* prop);
-  void ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd);
-  void ReadBinaryAnim( IOStream * stream, aiAnimation* anim );
-  void ReadBinaryTexture(IOStream * stream, aiTexture* tex);
-  void ReadBinaryLight( IOStream * stream, aiLight* l );
-  void ReadBinaryCamera( IOStream * stream, aiCamera* cam );
+    void ReadHeader();
+    void ReadBinaryScene( IOStream * stream, aiScene* pScene );
+    void ReadBinaryNode( IOStream * stream, aiNode** mRootNode, aiNode* parent );
+    void ReadBinaryMesh( IOStream * stream, aiMesh* mesh );
+    void ReadBinaryBone( IOStream * stream, aiBone* bone );
+    void ReadBinaryMaterial(IOStream * stream, aiMaterial* mat);
+    void ReadBinaryMaterialProperty(IOStream * stream, aiMaterialProperty* prop);
+    void ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd);
+    void ReadBinaryAnim( IOStream * stream, aiAnimation* anim );
+    void ReadBinaryTexture(IOStream * stream, aiTexture* tex);
+    void ReadBinaryLight( IOStream * stream, aiLight* l );
+    void ReadBinaryCamera( IOStream * stream, aiCamera* cam );
 };
 
 } // end of namespace Assimp

code/Assimp.cpp

@@ -272,8 +272,6 @@ void aiReleaseImport( const aiScene* pScene)
 
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
-    aiReleaseDefaultMaterial();
-
     // find the importer associated with this data
     const ScenePrivateData* priv = ScenePriv(pScene);
     if( !priv || !priv->mOrigImporter)  {

code/BVHLoader.cpp

@@ -54,6 +54,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/IOSystem.hpp>
 #include <assimp/scene.h>
 #include <assimp/importerdesc.h>
+#include <map>
 
 using namespace Assimp;
 using namespace Assimp::Formatter;
@@ -461,6 +462,13 @@ void BVHLoader::CreateAnimation( aiScene* pScene)
         aiNodeAnim* nodeAnim = new aiNodeAnim;
         anim->mChannels[a] = nodeAnim;
         nodeAnim->mNodeName.Set( nodeName);
+		std::map<BVHLoader::ChannelType, int> channelMap;
+
+		//Build map of channels 
+		for (unsigned int channel = 0; channel < node.mChannels.size(); ++channel)
+		{
+			channelMap[node.mChannels[channel]] = channel;
+		}
 
         // translational part, if given
         if( node.mChannels.size() == 6)
@@ -472,16 +480,32 @@ void BVHLoader::CreateAnimation( aiScene* pScene)
             {
                 poskey->mTime = double( fr);
 
-                // Now compute all translations in the right order
-                for( unsigned int channel = 0; channel < 3; ++channel)
+                // Now compute all translations 
+                for(BVHLoader::ChannelType channel = Channel_PositionX; channel <= Channel_PositionZ; channel = (BVHLoader::ChannelType)(channel +1))
                 {
-                    switch( node.mChannels[channel])
-                    {
-                    case Channel_PositionX: poskey->mValue.x = node.mChannelValues[fr * node.mChannels.size() + channel]; break;
-                    case Channel_PositionY: poskey->mValue.y = node.mChannelValues[fr * node.mChannels.size() + channel]; break;
-                    case Channel_PositionZ: poskey->mValue.z = node.mChannelValues[fr * node.mChannels.size() + channel]; break;
-                    default: throw DeadlyImportError( "Unexpected animation channel setup at node " + nodeName );
-                    }
+					//Find channel in node
+					std::map<BVHLoader::ChannelType, int>::iterator mapIter = channelMap.find(channel);
+
+					if (mapIter == channelMap.end())
+						throw DeadlyImportError("Missing position channel in node " + nodeName);
+					else {
+						int channelIdx = mapIter->second;
+						switch (channel) {
+						    case Channel_PositionX: 
+                                poskey->mValue.x = node.mChannelValues[fr * node.mChannels.size() + channelIdx]; 
+                                break;
+						    case Channel_PositionY: 
+                                poskey->mValue.y = node.mChannelValues[fr * node.mChannels.size() + channelIdx]; 
+                                break;
+						    case Channel_PositionZ: 
+                                poskey->mValue.z = node.mChannelValues[fr * node.mChannels.size() + channelIdx]; 
+                                break;
+                                
+                            default:
+                                break;
+						}
+
+					}
                 }
                 ++poskey;
             }
@@ -497,12 +521,6 @@ void BVHLoader::CreateAnimation( aiScene* pScene)
 
         // rotation part. Always present. First find value offsets
         {
-            unsigned int rotOffset  = 0;
-            if( node.mChannels.size() == 6)
-            {
-                // Offset all further calculations
-                rotOffset = 3;
-            }
 
             // Then create the number of rotation keys
             nodeAnim->mNumRotationKeys = mAnimNumFrames;
@@ -512,20 +530,33 @@ void BVHLoader::CreateAnimation( aiScene* pScene)
             {
                 aiMatrix4x4 temp;
                 aiMatrix3x3 rotMatrix;
-
-                for( unsigned int channel = 0; channel < 3; ++channel)
-                {
-                    // translate ZXY euler angels into a quaternion
-                    const float angle = node.mChannelValues[fr * node.mChannels.size() + rotOffset + channel] * float( AI_MATH_PI) / 180.0f;
-
-                    // Compute rotation transformations in the right order
-                    switch (node.mChannels[rotOffset+channel])
-                    {
-                    case Channel_RotationX: aiMatrix4x4::RotationX( angle, temp); rotMatrix *= aiMatrix3x3( temp); break;
-                    case Channel_RotationY: aiMatrix4x4::RotationY( angle, temp); rotMatrix *= aiMatrix3x3( temp);  break;
-                    case Channel_RotationZ: aiMatrix4x4::RotationZ( angle, temp); rotMatrix *= aiMatrix3x3( temp); break;
-                    default: throw DeadlyImportError( "Unexpected animation channel setup at node " + nodeName );
-                    }
+				for (BVHLoader::ChannelType channel = Channel_RotationX; channel <= Channel_RotationZ; channel = (BVHLoader::ChannelType)(channel + 1))
+				{
+					//Find channel in node
+					std::map<BVHLoader::ChannelType, int>::iterator mapIter = channelMap.find(channel);
+
+					if (mapIter == channelMap.end())
+						throw DeadlyImportError("Missing rotation channel in node " + nodeName);
+					else {
+						int channelIdx = mapIter->second;
+						// translate ZXY euler angels into a quaternion
+						const float angle = node.mChannelValues[fr * node.mChannels.size() + channelIdx] * float(AI_MATH_PI) / 180.0f;
+
+						// Compute rotation transformations in the right order
+						switch (channel)
+						{
+							case Channel_RotationX: 
+                                aiMatrix4x4::RotationX(angle, temp); rotMatrix *= aiMatrix3x3(temp); 
+                                break;
+							case Channel_RotationY: 
+                                aiMatrix4x4::RotationY(angle, temp); rotMatrix *= aiMatrix3x3(temp);  
+                                break;
+							case Channel_RotationZ: aiMatrix4x4::RotationZ(angle, temp); rotMatrix *= aiMatrix3x3(temp); 
+                                break;
+                            default:
+                                break;
+						}
+					}
                 }
 
                 rotkey->mTime = double( fr);

code/D3MFImporter.cpp

@@ -297,8 +297,9 @@ private:
             return false;
         }
 
+        //format of the color string: #RRGGBBAA or #RRGGBB (3MF Core chapter 5.1.1)
         const size_t len( strlen( color ) );
-        if ( 9 != len ) {
+        if ( 9 != len && 7 != len) {
             return false;
         }
 
@@ -313,26 +314,28 @@ private:
         ++buf;
         comp[ 1 ] = *buf;
         ++buf;
-        diffuse.r = static_cast<ai_real>( strtol( comp, NULL, 16 ) );
+        diffuse.r = static_cast<ai_real>( strtol( comp, NULL, 16 ) ) / 255.0;
 
 
         comp[ 0 ] = *buf;
         ++buf;
         comp[ 1 ] = *buf;
         ++buf;
-        diffuse.g = static_cast< ai_real >( strtol( comp, NULL, 16 ) );
+        diffuse.g = static_cast< ai_real >( strtol( comp, NULL, 16 ) ) / 255.0;
 
         comp[ 0 ] = *buf;
         ++buf;
         comp[ 1 ] = *buf;
         ++buf;
-        diffuse.b = static_cast< ai_real >( strtol( comp, NULL, 16 ) );
+        diffuse.b = static_cast< ai_real >( strtol( comp, NULL, 16 ) ) / 255.0;
 
+        if(7 == len)
+            return true;
         comp[ 0 ] = *buf;
         ++buf;
         comp[ 1 ] = *buf;
         ++buf;
-        diffuse.a = static_cast< ai_real >( strtol( comp, NULL, 16 ) );
+        diffuse.a = static_cast< ai_real >( strtol( comp, NULL, 16 ) ) / 255.0;
 
         return true;
     }

code/FBXConverter.cpp

@@ -185,12 +185,8 @@ void FBXConverter::ConvertNodes( uint64_t id, aiNode& parent, const aiMatrix4x4&
                 }
 
                 if ( !name_carrier ) {
-                    NodeNameCache::const_iterator it = mNodeNames.find(original_name);
-                    if ( it != mNodeNames.end() ) {
-                        original_name = original_name + std::string( "001" );
-                    }
-
-                    mNodeNames.insert( original_name );
+                    std::string old_original_name = original_name;
+                    GetUniqueName(old_original_name, original_name);
                     nodes_chain.push_back( new aiNode( original_name ) );
                 } else {
                     original_name = nodes_chain.back()->mName.C_Str();

code/FBXMeshGeometry.cpp

@@ -437,7 +437,7 @@ void ResolveVertexDataArray(std::vector<T>& data_out, const Scope& source,
     // deal with this more elegantly and with less redundancy, but right
     // now it seems unavoidable.
     if (MappingInformationType == "ByVertice" && isDirect) {
-        if (!HasElement(source, indexDataElementName)) {
+        if (!HasElement(source, dataElementName)) {
             return;
         }
         std::vector<T> tempData;

code/Importer.cpp

@@ -178,7 +178,6 @@ Importer::~Importer()
 {
     // Delete all import plugins
 	DeleteImporterInstanceList(pimpl->mImporter);
-    aiReleaseDefaultMaterial();
 
     // Delete all post-processing plug-ins
     for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++)
@@ -385,7 +384,6 @@ void Importer::FreeScene( )
 {
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
-    aiReleaseDefaultMaterial();
     delete pimpl->mScene;
     pimpl->mScene = NULL;
 

code/MDCLoader.cpp

@@ -434,10 +434,12 @@ void MDCImporter::InternReadFile(
     else if (1 == pScene->mNumMeshes)
     {
         pScene->mRootNode = new aiNode();
-        pScene->mRootNode->mName = pScene->mMeshes[0]->mName;
-        pScene->mRootNode->mNumMeshes = 1;
-        pScene->mRootNode->mMeshes = new unsigned int[1];
-        pScene->mRootNode->mMeshes[0] = 0;
+        if ( nullptr != pScene->mMeshes[0] ) {
+            pScene->mRootNode->mName = pScene->mMeshes[0]->mName;
+            pScene->mRootNode->mNumMeshes = 1;
+            pScene->mRootNode->mMeshes = new unsigned int[1];
+            pScene->mRootNode->mMeshes[0] = 0;
+        }
     }
     else
     {

code/MaterialSystem.cpp

@@ -387,26 +387,6 @@ aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat,
     return AI_SUCCESS;
 }
 
-static aiMaterial *DefaultMaterial = nullptr;
-
-// ------------------------------------------------------------------------------------------------
-// Will return the default material.
-aiMaterial *aiCreateAndRegisterDefaultMaterial() {
-    if (nullptr == DefaultMaterial) {
-        DefaultMaterial = new aiMaterial;
-        aiString s;
-        s.Set(AI_DEFAULT_MATERIAL_NAME);
-        DefaultMaterial->AddProperty(&s, AI_MATKEY_NAME);
-    }
-
-    return DefaultMaterial;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Will return the default material.
-void aiReleaseDefaultMaterial() {
-    DefaultMaterial = nullptr;
-}
 
 static const unsigned int DefaultNumAllocated = 5;
 

code/ObjFileImporter.cpp

@@ -210,22 +210,80 @@ void ObjFileImporter::CreateDataFromImport(const ObjFile::Model* pModel, aiScene
         ai_assert(false);
     }
 
-    // Create nodes for the whole scene
-    std::vector<aiMesh*> MeshArray;
-    for (size_t index = 0; index < pModel->m_Objects.size(); ++index ) {
-        createNodes(pModel, pModel->m_Objects[ index ], pScene->mRootNode, pScene, MeshArray);
-    }
+    if (pModel->m_Objects.size() > 0) {
+
+        unsigned int meshCount = 0;
+        unsigned int childCount = 0;
 
-    // Create mesh pointer buffer for this scene
-    if (pScene->mNumMeshes > 0) {
-        pScene->mMeshes = new aiMesh*[ MeshArray.size() ];
-        for (size_t index =0; index < MeshArray.size(); ++index ) {
-            pScene->mMeshes[ index ] = MeshArray[ index ];
+        for(size_t index = 0; index < pModel->m_Objects.size(); ++index) {
+            if(pModel->m_Objects[index]) {
+                ++childCount;
+                meshCount += (unsigned int)pModel->m_Objects[index]->m_Meshes.size();
+            }
+        }
+
+        // Allocate space for the child nodes on the root node
+        pScene->mRootNode->mChildren = new aiNode*[ childCount ];
+
+        // Create nodes for the whole scene
+        std::vector<aiMesh*> MeshArray;
+        MeshArray.reserve(meshCount);
+        for (size_t index = 0; index < pModel->m_Objects.size(); ++index) {
+            createNodes(pModel, pModel->m_Objects[index], pScene->mRootNode, pScene, MeshArray);
+        }
+
+        ai_assert(pScene->mRootNode->mNumChildren == childCount);
+
+        // Create mesh pointer buffer for this scene
+        if (pScene->mNumMeshes > 0) {
+            pScene->mMeshes = new aiMesh*[MeshArray.size()];
+            for (size_t index = 0; index < MeshArray.size(); ++index) {
+                pScene->mMeshes[index] = MeshArray[index];
+            }
+        }
+
+        // Create all materials
+        createMaterials(pModel, pScene);
+    }else {
+		if (pModel->m_Vertices.empty()){
+			return;
+		}
+
+		std::unique_ptr<aiMesh> mesh( new aiMesh );
+        mesh->mPrimitiveTypes = aiPrimitiveType_POINT;
+        unsigned int n = pModel->m_Vertices.size();
+        mesh->mNumVertices = n;
+
+        mesh->mVertices = new aiVector3D[n];
+        memcpy(mesh->mVertices, pModel->m_Vertices.data(), n*sizeof(aiVector3D) );
+
+        if ( !pModel->m_Normals.empty() ) {
+            mesh->mNormals = new aiVector3D[n];
+            if (pModel->m_Normals.size() < n) {
+                throw DeadlyImportError("OBJ: vertex normal index out of range");
+            }
+            memcpy(mesh->mNormals, pModel->m_Normals.data(), n*sizeof(aiVector3D));
         }
-    }
 
-    // Create all materials
-    createMaterials( pModel, pScene );
+        if ( !pModel->m_VertexColors.empty() ){
+            mesh->mColors[0] = new aiColor4D[mesh->mNumVertices];
+            for (unsigned int i = 0; i < n; ++i) {
+                if (i < pModel->m_VertexColors.size() ) {
+                    const aiVector3D& color = pModel->m_VertexColors[i];
+                    mesh->mColors[0][i] = aiColor4D(color.x, color.y, color.z, 1.0);
+                }else {
+                    throw DeadlyImportError("OBJ: vertex color index out of range");
+                }
+            }
+        }
+
+        pScene->mRootNode->mNumMeshes = 1;
+        pScene->mRootNode->mMeshes = new unsigned int[1];
+        pScene->mRootNode->mMeshes[0] = 0;
+        pScene->mMeshes = new aiMesh*[1];
+        pScene->mNumMeshes = 1;
+        pScene->mMeshes[0] = mesh.release();
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -246,9 +304,8 @@ aiNode *ObjFileImporter::createNodes(const ObjFile::Model* pModel, const ObjFile
     pNode->mName = pObject->m_strObjName;
 
     // If we have a parent node, store it
-    if( pParent != NULL ) {
-        appendChildToParentNode( pParent, pNode );
-    }
+    ai_assert( NULL != pParent );
+    appendChildToParentNode( pParent, pNode );
 
     for ( size_t i=0; i< pObject->m_Meshes.size(); ++i ) {
         unsigned int meshId = pObject->m_Meshes[ i ];
@@ -401,8 +458,8 @@ void ObjFileImporter::createVertexArray(const ObjFile::Model* pModel,
     pMesh->mNumVertices = numIndices;
     if (pMesh->mNumVertices == 0) {
         throw DeadlyImportError( "OBJ: no vertices" );
-    } else if (pMesh->mNumVertices > AI_MAX_ALLOC(aiVector3D)) {
-        throw DeadlyImportError( "OBJ: Too many vertices, would run out of memory" );
+    } else if (pMesh->mNumVertices > AI_MAX_VERTICES) {
+        throw DeadlyImportError( "OBJ: Too many vertices" );
     }
     pMesh->mVertices = new aiVector3D[ pMesh->mNumVertices ];
 
@@ -452,7 +509,7 @@ void ObjFileImporter::createVertexArray(const ObjFile::Model* pModel,
             // Copy all vertex colors
             if ( !pModel->m_VertexColors.empty())
             {
-                const aiVector3D color = pModel->m_VertexColors[ vertex ];
+                const aiVector3D& color = pModel->m_VertexColors[ vertex ];
                 pMesh->mColors[0][ newIndex ] = aiColor4D(color.x, color.y, color.z, 1.0);
             }
 
@@ -729,25 +786,8 @@ void ObjFileImporter::appendChildToParentNode(aiNode *pParent, aiNode *pChild)
     // Assign parent to child
     pChild->mParent = pParent;
 
-    // If already children was assigned to the parent node, store them in a
-    std::vector<aiNode*> temp;
-    if (pParent->mChildren != NULL)
-    {
-        ai_assert( 0 != pParent->mNumChildren );
-        for (size_t index = 0; index < pParent->mNumChildren; index++)
-        {
-            temp.push_back(pParent->mChildren [ index ] );
-        }
-        delete [] pParent->mChildren;
-    }
-
     // Copy node instances into parent node
     pParent->mNumChildren++;
-    pParent->mChildren = new aiNode*[ pParent->mNumChildren ];
-    for (size_t index = 0; index < pParent->mNumChildren-1; index++)
-    {
-        pParent->mChildren[ index ] = temp [ index ];
-    }
     pParent->mChildren[ pParent->mNumChildren-1 ] = pChild;
 }
 

code/STLLoader.cpp

@@ -214,11 +214,10 @@ void STLImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
 
     // create a single default material, using a white diffuse color for consistency with
     // other geometric types (e.g., PLY).
-    aiMaterial* pcMat = aiCreateAndRegisterDefaultMaterial();
-    /*aiMaterial* pcMat = new aiMaterial();
+    aiMaterial* pcMat = new aiMaterial();
     aiString s;
     s.Set(AI_DEFAULT_MATERIAL_NAME);
-    pcMat->AddProperty(&s, AI_MATKEY_NAME);*/
+    pcMat->AddProperty(&s, AI_MATKEY_NAME);
 
     aiColor4D clrDiffuse(ai_real(1.0),ai_real(1.0),ai_real(1.0),ai_real(1.0));
     if (bMatClr) {

code/SplitByBoneCountProcess.cpp

@@ -393,7 +393,7 @@ void SplitByBoneCountProcess::UpdateNode( aiNode* pNode) const
             newMeshList.insert( newMeshList.end(), replaceMeshes.begin(), replaceMeshes.end());
         }
 
-        delete pNode->mMeshes;
+        delete [] pNode->mMeshes;
         pNode->mNumMeshes = static_cast<unsigned int>(newMeshList.size());
         pNode->mMeshes = new unsigned int[pNode->mNumMeshes];
         std::copy( newMeshList.begin(), newMeshList.end(), pNode->mMeshes);

code/glTF2Importer.cpp

@@ -437,6 +437,12 @@ void glTF2Importer::ImportMeshes(glTF2::Asset& r)
             }
 
             for (size_t tc = 0; tc < attr.texcoord.size() && tc < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++tc) {
+                if (attr.texcoord[tc]->count != aim->mNumVertices) {
+                    DefaultLogger::get()->warn("Texcoord stream size in mesh \"" + mesh.name +
+                                               "\" does not match the vertex count");
+                    continue;
+                }
+
                 attr.texcoord[tc]->ExtractData(aim->mTextureCoords[tc]);
                 aim->mNumUVComponents[tc] = attr.texcoord[tc]->GetNumComponents();
 

include/assimp/DefaultIOSystem.h

@@ -50,8 +50,7 @@ namespace Assimp    {
 
 // ---------------------------------------------------------------------------
 /** Default implementation of IOSystem using the standard C file functions */
-class ASSIMP_API DefaultIOSystem : public IOSystem
-{
+class ASSIMP_API DefaultIOSystem : public IOSystem {
 public:
     // -------------------------------------------------------------------
     /** Tests for the existence of a file at the given path. */

include/assimp/LineSplitter.h

@@ -44,11 +44,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief LineSplitter, a helper class to iterate through all lines
  *    of a file easily. Works with StreamReader.
  */
+#pragma once
 #ifndef INCLUDED_LINE_SPLITTER_H
 #define INCLUDED_LINE_SPLITTER_H
 
 #include <stdexcept>
-
 #include "StreamReader.h"
 #include "ParsingUtils.h"
 
@@ -81,164 +81,205 @@ public:
     /** construct from existing stream reader
     note: trim is *always* assumed true if skyp_empty_lines==true
     */
-    LineSplitter(StreamReaderLE& stream, bool skip_empty_lines = true, bool trim = true)
-    : idx( 0 )
-    , stream(stream)
-    , swallow()
-    , skip_empty_lines(skip_empty_lines)
-    , trim(trim) {
-        cur.reserve(1024);
-        operator++();
-
-        idx = 0;
-    }
-
-    ~LineSplitter() {
-        // empty
-    }
+    LineSplitter(StreamReaderLE& stream, bool skip_empty_lines = true, bool trim = true);
 
-public:
+    ~LineSplitter();
 
     // -----------------------------------------
     /** pseudo-iterator increment */
-    LineSplitter& operator++() {
-        if(swallow) {
-            swallow = false;
-            return *this;
-        }
-        if (!*this) {
-            throw std::logic_error("End of file, no more lines to be retrieved.");
-        }
-        char s;
-        cur.clear();
-        while(stream.GetRemainingSize() && (s = stream.GetI1(),1)) {
-            if (s == '\n' || s == '\r') {
-                if (skip_empty_lines) {
-                    while (stream.GetRemainingSize() && ((s = stream.GetI1()) == ' ' || s == '\r' || s == '\n'));
-                    if (stream.GetRemainingSize()) {
-                        stream.IncPtr(-1);
-                    }
-                }
-                else {
-                    // skip both potential line terminators but don't read past this line.
-                    if (stream.GetRemainingSize() && (s == '\r' && stream.GetI1() != '\n')) {
-                        stream.IncPtr(-1);
-                    }
-                    if (trim) {
-                        while (stream.GetRemainingSize() && ((s = stream.GetI1()) == ' ' || s == '\t'));
-                        if (stream.GetRemainingSize()) {
-                            stream.IncPtr(-1);
-                        }
-                    }
-                }
-                break;
-            }
-            cur += s;
-        }
-        ++idx;
-        return *this;
-    }
+    LineSplitter& operator++();
 
     // -----------------------------------------
-    LineSplitter& operator++(int) {
-        return ++(*this);
-    }
+    LineSplitter& operator++(int);
 
     // -----------------------------------------
     /** get a pointer to the beginning of a particular token */
-    const char* operator[] (size_t idx) const {
-        const char* s = operator->()->c_str();
-
-        SkipSpaces(&s);
-        for(size_t i = 0; i < idx; ++i) {
-
-            for(;!IsSpace(*s); ++s) {
-                if(IsLineEnd(*s)) {
-                    throw std::range_error("Token index out of range, EOL reached");
-                }
-            }
-            SkipSpaces(&s);
-        }
-        return s;
-    }
+    const char* operator[] (size_t idx) const;
 
     // -----------------------------------------
     /** extract the start positions of N tokens from the current line*/
     template <size_t N>
-    void get_tokens(const char* (&tokens)[N]) const {
-        const char* s = operator->()->c_str();
-
-        SkipSpaces(&s);
-        for(size_t i = 0; i < N; ++i) {
-            if(IsLineEnd(*s)) {
-
-                throw std::range_error("Token count out of range, EOL reached");
-
-            }
-            tokens[i] = s;
-
-            for(;*s && !IsSpace(*s); ++s);
-            SkipSpaces(&s);
-        }
-    }
+    void get_tokens(const char* (&tokens)[N]) const;
 
     // -----------------------------------------
     /** member access */
-    const std::string* operator -> () const {
-        return &cur;
-    }
+    const std::string* operator -> () const;
 
-    std::string operator* () const {
-        return cur;
-    }
+    std::string operator* () const;
 
     // -----------------------------------------
     /** boolean context */
-    operator bool() const {
-        return stream.GetRemainingSize()>0;
-    }
+    operator bool() const;
 
     // -----------------------------------------
     /** line indices are zero-based, empty lines are included */
-    operator line_idx() const {
-        return idx;
-    }
+    operator line_idx() const;
 
-    line_idx get_index() const {
-        return idx;
-    }
+    line_idx get_index() const;
 
     // -----------------------------------------
     /** access the underlying stream object */
-    StreamReaderLE& get_stream() {
-        return stream;
-    }
+    StreamReaderLE& get_stream();
 
     // -----------------------------------------
     /** !strcmp((*this)->substr(0,strlen(check)),check) */
-    bool match_start(const char* check) {
-        const size_t len = strlen(check);
-
-        return len <= cur.length() && std::equal(check,check+len,cur.begin());
-    }
-
+    bool match_start(const char* check);
 
     // -----------------------------------------
     /** swallow the next call to ++, return the previous value. */
-    void swallow_next_increment() {
-        swallow = true;
-    }
+    void swallow_next_increment();
 
-private:
-    LineSplitter( const LineSplitter & );
-    LineSplitter &operator = ( const LineSplitter & );
+    LineSplitter( const LineSplitter & ) = delete;
+    LineSplitter(LineSplitter &&) = delete;
+    LineSplitter &operator = ( const LineSplitter & ) = delete;
 
 private:
-    line_idx idx;
-    std::string cur;
-    StreamReaderLE& stream;
-    bool swallow, skip_empty_lines, trim;
+    line_idx mIdx;
+    std::string mCur;
+    StreamReaderLE& mStream;
+    bool mSwallow, mSkip_empty_lines, mTrim;
 };
 
+inline
+LineSplitter::LineSplitter(StreamReaderLE& stream, bool skip_empty_lines, bool trim )
+: mIdx(0)
+, mCur()
+, mStream(stream)
+, mSwallow()
+, mSkip_empty_lines(skip_empty_lines)
+, mTrim(trim) {
+    mCur.reserve(1024);
+    operator++();
+    mIdx = 0;
+}
+
+inline
+LineSplitter::~LineSplitter() {
+    // empty
+}
+
+inline
+LineSplitter& LineSplitter::operator++() {
+    if (mSwallow) {
+        mSwallow = false;
+        return *this;
+    }
+
+    if (!*this) {
+        throw std::logic_error("End of file, no more lines to be retrieved.");
+    }
+
+    char s;
+    mCur.clear();
+    while (mStream.GetRemainingSize() && (s = mStream.GetI1(), 1)) {
+        if (s == '\n' || s == '\r') {
+            if (mSkip_empty_lines) {
+                while (mStream.GetRemainingSize() && ((s = mStream.GetI1()) == ' ' || s == '\r' || s == '\n'));
+                if (mStream.GetRemainingSize()) {
+                    mStream.IncPtr(-1);
+                }
+            } else {
+                // skip both potential line terminators but don't read past this line.
+                if (mStream.GetRemainingSize() && (s == '\r' && mStream.GetI1() != '\n')) {
+                    mStream.IncPtr(-1);
+                }
+                if (mTrim) {
+                    while (mStream.GetRemainingSize() && ((s = mStream.GetI1()) == ' ' || s == '\t'));
+                    if (mStream.GetRemainingSize()) {
+                        mStream.IncPtr(-1);
+                    }
+                }
+            }
+            break;
+        }
+        mCur += s;
+    }
+    ++mIdx;
+
+    return *this;
+}
+
+inline
+LineSplitter &LineSplitter::operator++(int) {
+    return ++(*this);
+}
+
+inline
+const char *LineSplitter::operator[] (size_t idx) const {
+    const char* s = operator->()->c_str();
+
+    SkipSpaces(&s);
+    for (size_t i = 0; i < idx; ++i) {
+
+        for (; !IsSpace(*s); ++s) {
+            if (IsLineEnd(*s)) {
+                throw std::range_error("Token index out of range, EOL reached");
+            }
+        }
+        SkipSpaces(&s);
+    }
+    return s;
+}
+
+template <size_t N>
+inline
+void LineSplitter::get_tokens(const char* (&tokens)[N]) const {
+    const char* s = operator->()->c_str();
+
+    SkipSpaces(&s);
+    for (size_t i = 0; i < N; ++i) {
+        if (IsLineEnd(*s)) {
+            throw std::range_error("Token count out of range, EOL reached");
+        }
+        tokens[i] = s;
+
+        for (; *s && !IsSpace(*s); ++s);
+        SkipSpaces(&s);
+    }
+}
+
+inline
+const std::string* LineSplitter::operator -> () const {
+    return &mCur;
+}
+
+inline
+std::string LineSplitter::operator* () const {
+    return mCur;
+}
+
+inline
+LineSplitter::operator bool() const {
+    return mStream.GetRemainingSize() > 0;
+}
+
+inline
+LineSplitter::operator line_idx() const {
+    return mIdx;
+}
+
+inline
+LineSplitter::line_idx LineSplitter::get_index() const {
+    return mIdx;
+}
+
+inline
+StreamReaderLE &LineSplitter::get_stream() {
+    return mStream;
+}
+
+inline
+bool LineSplitter::match_start(const char* check) {
+    const size_t len = ::strlen(check);
+
+    return len <= mCur.length() && std::equal(check, check + len, mCur.begin());
+}
+
+inline
+void LineSplitter::swallow_next_increment() {
+    mSwallow = true;
 }
+
+} // Namespace Assimp
+
 #endif // INCLUDED_LINE_SPLITTER_H

include/assimp/StreamReader.h

@@ -67,16 +67,13 @@ namespace Assimp {
  *  XXX switch from unsigned int for size types to size_t? or ptrdiff_t?*/
 // --------------------------------------------------------------------------------------------
 template <bool SwapEndianess = false, bool RuntimeSwitch = false>
-class StreamReader
-{
+class StreamReader {
 public:
     // FIXME: use these data types throughout the whole library,
     // then change them to 64 bit values :-)
+    using diff = int;
+    using pos  = unsigned int;
 
-    typedef int diff;
-    typedef unsigned int pos;
-
-public:
     // ---------------------------------------------------------------------
     /** Construction from a given stream with a well-defined endianness.
      *
@@ -111,8 +108,6 @@ public:
         delete[] buffer;
     }
 
-public:
-
     // deprecated, use overloaded operator>> instead
 
     // ---------------------------------------------------------------------
@@ -176,7 +171,6 @@ public:
         return Get<uint64_t>();
     }
 
-public:
     // ---------------------------------------------------------------------
     /** Get the remaining stream size (to the end of the stream) */
     unsigned int GetRemainingSize() const {

include/assimp/material.h

@@ -1565,26 +1565,6 @@ C_ENUM aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat,
     unsigned int* flags                 /*= NULL*/);
 #endif // !#ifdef __cplusplus
 
-// ---------------------------------------------------------------------------
-/** @brief  Helper function to get all values pertaining to a particular
-*  texture slot from a material structure.
-*
-*  @return Pointer showing to the default material.
-*/
-// ---------------------------------------------------------------------------
-#ifdef __cplusplus
-ASSIMP_API aiMaterial *aiCreateAndRegisterDefaultMaterial(void);
-#else
-C_STRUCT aiMaterial *aiCreateAndRegisterDefaultMaterial(void);
-#endif // !#ifdef __cplusplus
-
-// ---------------------------------------------------------------------------
-/**
-  * @brief  Helper function to release the default material instance, the
-  *         instance will not be destroyed.
-  */
-// ---------------------------------------------------------------------------
-ASSIMP_API void aiReleaseDefaultMaterial();
 
 #ifdef __cplusplus
 }

port/PyAssimp/pyassimp/core.py

@@ -66,6 +66,13 @@ def make_tuple(ai_obj, type = None):
 
     return res
 
+# Returns unicode object for Python 2, and str object for Python 3.
+def _convert_assimp_string(assimp_string):
+    try:
+        return unicode(assimp_string.data, errors='ignore')
+    except:
+        return str(assimp_string.data, errors='ignore')
+
 # It is faster and more correct to have an init function for each assimp class
 def _init_face(aiFace):
     aiFace.indices = [aiFace.mIndices[i] for i in range(aiFace.mNumIndices)]
@@ -118,14 +125,9 @@ def _init(self, target = None, parent = None):
                 continue
 
         if m == 'mName':
-            obj = self.mName
-            try:
-                uni = unicode(obj.data, errors='ignore')
-            except:
-                uni = str(obj.data, errors='ignore')
-            target.name = str( uni )
-            target.__class__.__repr__ = lambda x: str(x.__class__) + "(" + x.name + ")"
-            target.__class__.__str__ = lambda x: x.name
+            target.name = str(_convert_assimp_string(self.mName))
+            target.__class__.__repr__ = lambda x: str(x.__class__) + "(" + getattr(x, 'name','') + ")"
+            target.__class__.__str__ = lambda x: getattr(x, 'name', '')
             continue
 
         name = m[1:].lower()
@@ -220,6 +222,9 @@ def _init(self, target = None, parent = None):
     if isinstance(self, structs.Texture):
         _finalize_texture(self, target)
 
+    if isinstance(self, structs.Metadata):
+        _finalize_metadata(self, target)
+
 
     return self
 
@@ -412,6 +417,43 @@ def _finalize_mesh(mesh, target):
         faces = [f.indices for f in target.faces]
     setattr(target, 'faces', faces)
 
+def _init_metadata_entry(entry):
+    from ctypes import POINTER, c_bool, c_int32, c_uint64, c_float, c_double, cast
+
+    entry.type = entry.mType
+    if entry.type == structs.MetadataEntry.AI_BOOL:
+        entry.data = cast(entry.mData, POINTER(c_bool)).contents.value
+    elif entry.type == structs.MetadataEntry.AI_INT32:
+        entry.data = cast(entry.mData, POINTER(c_int32)).contents.value
+    elif entry.type == structs.MetadataEntry.AI_UINT64:
+        entry.data = cast(entry.mData, POINTER(c_uint64)).contents.value
+    elif entry.type == structs.MetadataEntry.AI_FLOAT:
+        entry.data = cast(entry.mData, POINTER(c_float)).contents.value
+    elif entry.type == structs.MetadataEntry.AI_DOUBLE:
+        entry.data = cast(entry.mData, POINTER(c_double)).contents.value
+    elif entry.type == structs.MetadataEntry.AI_AISTRING:
+        assimp_string = cast(entry.mData, POINTER(structs.String)).contents
+        entry.data = _convert_assimp_string(assimp_string)
+    elif entry.type == structs.MetadataEntry.AI_AIVECTOR3D:
+        assimp_vector = cast(entry.mData, POINTER(structs.Vector3D)).contents
+        entry.data = make_tuple(assimp_vector)
+
+    return entry
+
+def _finalize_metadata(metadata, target):
+    """ Building the metadata object is a bit specific.
+
+    Firstly, there are two separate arrays: one with metadata keys and one
+    with metadata values, and there are no corresponding mNum* attributes,
+    so the C arrays are not converted to Python arrays using the generic
+    code in the _init function.
+
+    Secondly, a metadata entry value has to be cast according to declared
+    metadata entry type.
+    """
+    length = metadata.mNumProperties
+    setattr(target, 'keys', [str(_convert_assimp_string(metadata.mKeys[i])) for i in range(length)])
+    setattr(target, 'values', [_init_metadata_entry(metadata.mValues[i]) for i in range(length)])
 
 class PropertyGetter(dict):
     def __getitem__(self, key):
@@ -443,11 +485,8 @@ def _get_properties(properties, length):
     for p in [properties[i] for i in range(length)]:
         #the name
         p = p.contents
-        try:
-            uni = unicode(p.mKey.data, errors='ignore')
-        except:
-            uni = str(p.mKey.data, errors='ignore')
-        key = (str(uni).split('.')[1], p.mSemantic)
+        key = str(_convert_assimp_string(p.mKey))
+        key = (key.split('.')[1], p.mSemantic)
 
         #the data
         from ctypes import POINTER, cast, c_int, c_float, sizeof
@@ -455,11 +494,7 @@ def _get_properties(properties, length):
             arr = cast(p.mData, POINTER(c_float * int(p.mDataLength/sizeof(c_float)) )).contents
             value = [x for x in arr]
         elif p.mType == 3: #string can't be an array
-            try:
-                uni = unicode(cast(p.mData, POINTER(structs.MaterialPropertyString)).contents.data, errors='ignore')
-            except:
-                uni = str(cast(p.mData, POINTER(structs.MaterialPropertyString)).contents.data, errors='ignore')
-            value = uni
+            value = _convert_assimp_string(cast(p.mData, POINTER(structs.MaterialPropertyString)).contents)
 
         elif p.mType == 4:
             arr = cast(p.mData, POINTER(c_int * int(p.mDataLength/sizeof(c_int)) )).contents

port/PyAssimp/pyassimp/structs.py

@@ -5,7 +5,7 @@ from ctypes import POINTER, c_void_p, c_int, c_uint, c_char, c_float, Structure,
 
 class Vector2D(Structure):
     """
-    See 'aiVector2D.h' for details.
+    See 'vector2.h' for details.
     """ 
 
 
@@ -15,7 +15,7 @@ class Vector2D(Structure):
 
 class Matrix3x3(Structure):
     """
-    See 'aiMatrix3x3.h' for details.
+    See 'matrix3x3.h' for details.
     """ 
 
 
@@ -27,7 +27,7 @@ class Matrix3x3(Structure):
 
 class Texel(Structure):
     """
-    See 'aiTexture.h' for details.
+    See 'texture.h' for details.
     """ 
 
     _fields_ = [
@@ -36,7 +36,7 @@ class Texel(Structure):
 
 class Color4D(Structure):
     """
-    See 'aiColor4D.h' for details.
+    See 'color4.h' for details.
     """ 
 
 
@@ -47,7 +47,7 @@ class Color4D(Structure):
 
 class Plane(Structure):
     """
-    See 'aiTypes.h' for details.
+    See 'types.h' for details.
     """ 
 
     _fields_ = [
@@ -57,7 +57,7 @@ class Plane(Structure):
 
 class Color3D(Structure):
     """
-    See 'aiTypes.h' for details.
+    See 'types.h' for details.
     """ 
 
     _fields_ = [
@@ -67,7 +67,7 @@ class Color3D(Structure):
 
 class String(Structure):
     """
-    See 'aiTypes.h' for details.
+    See 'types.h' for details.
     """ 
 
     MAXLEN = 1024
@@ -84,7 +84,7 @@ class String(Structure):
 
 class MaterialPropertyString(Structure):
     """
-    See 'aiTypes.h' for details.
+    See 'MaterialSystem.cpp' for details.
     
     The size of length is truncated to 4 bytes on 64-bit platforms when used as a
     material property (see MaterialSystem.cpp aiMaterial::AddProperty() for details).
@@ -104,7 +104,7 @@ class MaterialPropertyString(Structure):
 
 class MemoryInfo(Structure):
     """
-    See 'aiTypes.h' for details.
+    See 'types.h' for details.
     """ 
 
     _fields_ = [
@@ -135,7 +135,7 @@ class MemoryInfo(Structure):
 
 class Quaternion(Structure):
     """
-    See 'aiQuaternion.h' for details.
+    See 'quaternion.h' for details.
     """ 
 
 
@@ -146,7 +146,7 @@ class Quaternion(Structure):
 
 class Face(Structure):
     """
-    See 'aiMesh.h' for details.
+    See 'mesh.h' for details.
     """ 
 
     _fields_ = [
@@ -161,7 +161,7 @@ class Face(Structure):
 
 class VertexWeight(Structure):
     """
-    See 'aiMesh.h' for details.
+    See 'mesh.h' for details.
     """ 
 
     _fields_ = [
@@ -175,7 +175,7 @@ class VertexWeight(Structure):
 
 class Matrix4x4(Structure):
     """
-    See 'aiMatrix4x4.h' for details.
+    See 'matrix4x4.h' for details.
     """ 
 
 
@@ -188,7 +188,7 @@ class Matrix4x4(Structure):
 
 class Vector3D(Structure):
     """
-    See 'aiVector3D.h' for details.
+    See 'vector3.h' for details.
     """ 
 
 
@@ -198,7 +198,7 @@ class Vector3D(Structure):
 
 class MeshKey(Structure):
     """
-    See 'aiAnim.h' for details.
+    See 'anim.h' for details.
     """ 
 
     _fields_ = [
@@ -214,9 +214,44 @@ class MeshKey(Structure):
             ("mValue", c_uint),
         ]
 
+class MetadataEntry(Structure):
+    """
+    See 'metadata.h' for details
+    """
+    AI_BOOL       = 0
+    AI_INT32      = 1
+    AI_UINT64     = 2
+    AI_FLOAT      = 3
+    AI_DOUBLE     = 4
+    AI_AISTRING   = 5
+    AI_AIVECTOR3D = 6
+    AI_META_MAX   = 7
+    _fields_ = [
+            # The type field uniquely identifies the underlying type of the data field
+            ("mType", c_uint),
+            ("mData", c_void_p),
+    ]
+
+class Metadata(Structure):
+    """
+    See 'metadata.h' for details
+    """
+    _fields_ = [
+            # Length of the mKeys and mValues arrays, respectively
+            ("mNumProperties", c_uint),
+
+            # Arrays of keys, may not be NULL. Entries in this array may not be NULL
+            # as well.
+            ("mKeys", POINTER(String)),
+
+            # Arrays of values, may not be NULL. Entries in this array may be NULL
+            # if the corresponding property key has no assigned value.
+            ("mValues", POINTER(MetadataEntry)),
+    ]
+
 class Node(Structure):
     """
-    See 'aiScene.h' for details.
+    See 'scene.h' for details.
     """ 
 
 
@@ -253,11 +288,15 @@ Node._fields_ = [
             
             # The meshes of this node. Each entry is an index into the mesh
             ("mMeshes", POINTER(c_uint)),
+
+            # Metadata associated with this node or NULL if there is no metadata.
+            # Whether any metadata is generated depends on the source file format.
+            ("mMetadata", POINTER(Metadata)),
         ]
 
 class Light(Structure):
     """
-    See 'aiLight.h' for details.
+    See 'light.h' for details.
     """ 
 
 
@@ -283,6 +322,13 @@ class Light(Structure):
             #  may be normalized, but it needn't.
             ("mDirection", Vector3D),
             
+            # Up direction of the light source in space. Relative to the
+            #  transformation of the node corresponding to the light.
+            #
+            # The direction is undefined for point lights. The vector
+            #  may be normalized, but it needn't.
+            ("mUp", Vector3D),
+
             # Constant light attenuation factor.
             #  The intensity of the light source at a given distance 'd' from
             #  the light's position is
@@ -354,11 +400,14 @@ class Light(Structure):
             #  interpolation between the inner and the outer cone of the
             #  spot light.
             ("mAngleOuterCone", c_float),
+
+            # Size of area light source.
+            ("mSize", Vector2D),
         ]
 
 class Texture(Structure):
     """
-    See 'aiTexture.h' for details.
+    See 'texture.h' for details.
     """ 
 
 
@@ -375,16 +424,25 @@ class Texture(Structure):
             ("mHeight", c_uint),
             
             # A hint from the loader to make it easier for applications
-            #  to determine the type of embedded compressed textures.
-            # If mHeight != 0 this member is undefined. Otherwise it
-            # is set set to '\\0\\0\\0\\0' if the loader has no additional
+            # to determine the type of embedded textures.
+            # 
+            # If mHeight != 0 this member is show how data is packed. Hint will consist of
+            # two parts: channel order and channel bitness (count of the bits for every
+            # color channel). For simple parsing by the viewer it's better to not omit
+            # absent color channel and just use 0 for bitness. For example:
+            # 1. Image contain RGBA and 8 bit per channel, achFormatHint == "rgba8888";
+            # 2. Image contain ARGB and 8 bit per channel, achFormatHint == "argb8888";
+            # 3. Image contain RGB and 5 bit for R and B channels and 6 bit for G channel,
+            #    achFormatHint == "rgba5650";
+            # 4. One color image with B channel and 1 bit for it, achFormatHint == "rgba0010";
+            # If mHeight == 0 then achFormatHint is set set to '\\0\\0\\0\\0' if the loader has no additional
             # information about the texture file format used OR the
             # file extension of the format without a trailing dot. If there
             # are multiple file extensions for a format, the shortest
             # extension is chosen (JPEG maps to 'jpg', not to 'jpeg').
             # E.g. 'dds\\0', 'pcx\\0', 'jpg\\0'.  All characters are lower-case.
             # The fourth character will always be '\\0'.
-            ("achFormatHint", c_char*4),
+            ("achFormatHint", c_char*9),
             
             # Data of the texture.
             # Points to an array of mWidth
@@ -395,11 +453,15 @@ class Texture(Structure):
             # buffer of size mWidth containing the compressed texture
             # data. Good luck, have fun!
             ("pcData", POINTER(Texel)),
+
+            # Texture original filename
+            # Used to get the texture reference
+            ("mFilename", String),
         ]
 
 class Ray(Structure):
     """
-    See 'aiTypes.h' for details.
+    See 'types.h' for details.
     """ 
 
     _fields_ = [
@@ -409,7 +471,7 @@ class Ray(Structure):
 
 class UVTransform(Structure):
     """
-    See 'aiMaterial.h' for details.
+    See 'material.h' for details.
     """ 
 
     _fields_ = [
@@ -430,7 +492,7 @@ class UVTransform(Structure):
 
 class MaterialProperty(Structure):
     """
-    See 'aiMaterial.h' for details.
+    See 'material.h' for details.
     """ 
 
     _fields_ = [
@@ -466,7 +528,7 @@ class MaterialProperty(Structure):
 
 class Material(Structure):
     """
-    See 'aiMaterial.h' for details.
+    See 'material.h' for details.
     """ 
 
     _fields_ = [
@@ -482,7 +544,7 @@ class Material(Structure):
 
 class Bone(Structure):
     """
-    See 'aiMesh.h' for details.
+    See 'mesh.h' for details.
     """ 
 
     _fields_ = [
@@ -501,20 +563,66 @@ class Bone(Structure):
             ("mOffsetMatrix", Matrix4x4),
         ]
 
-class Mesh(Structure):
+
+class AnimMesh(Structure):
     """
-    See 'aiMesh.h' for details.
+    See 'mesh.h' for details.
     """ 
 
-    AI_MAX_FACE_INDICES = 0x7fff
-    AI_MAX_BONE_WEIGHTS = 0x7fffffff
-    AI_MAX_VERTICES = 0x7fffffff
-    AI_MAX_FACES = 0x7fffffff
-    AI_MAX_NUMBER_OF_COLOR_SETS = 0x8
-    AI_MAX_NUMBER_OF_TEXTURECOORDS = 0x8
+    AI_MAX_NUMBER_OF_TEXTURECOORDS = 0x8
+    AI_MAX_NUMBER_OF_COLOR_SETS = 0x8
 
     _fields_ = [
-            # Bitwise combination of the members of the
+            # Replacement for aiMesh::mVertices. If this array is non-NULL,
+            # it *must* contain mNumVertices entries. The corresponding
+            # array in the host mesh must be non-NULL as well - animation
+            # meshes may neither add or nor remove vertex components (if
+            # a replacement array is NULL and the corresponding source
+            # array is not, the source data is taken instead)
+            ("mVertices", POINTER(Vector3D)),
+
+            # Replacement for aiMesh::mNormals.
+            ("mNormals", POINTER(Vector3D)),
+
+            # Replacement for aiMesh::mTangents.
+            ("mTangents", POINTER(Vector3D)),
+
+            # Replacement for aiMesh::mBitangents.
+            ("mBitangents", POINTER(Vector3D)),
+
+            # Replacement for aiMesh::mColors
+            ("mColors", POINTER(Color4D) * AI_MAX_NUMBER_OF_COLOR_SETS),
+
+            # Replacement for aiMesh::mTextureCoords
+            ("mTextureCoords", POINTER(Vector3D) * AI_MAX_NUMBER_OF_TEXTURECOORDS),
+
+            # The number of vertices in the aiAnimMesh, and thus the length of all
+            # the member arrays.
+            #
+            # This has always the same value as the mNumVertices property in the
+            # corresponding aiMesh. It is duplicated here merely to make the length
+            # of the member arrays accessible even if the aiMesh is not known, e.g.
+            # from language bindings.
+            ("mNumVertices", c_uint),
+
+            # Weight of the AnimMesh.
+            ("mWeight", c_float),
+        ]
+
+
+class Mesh(Structure):
+    """
+    See 'mesh.h' for details.
+    """ 
+
+    AI_MAX_FACE_INDICES = 0x7fff
+    AI_MAX_BONE_WEIGHTS = 0x7fffffff
+    AI_MAX_VERTICES = 0x7fffffff
+    AI_MAX_FACES = 0x7fffffff
+    AI_MAX_NUMBER_OF_COLOR_SETS = 0x8
+    AI_MAX_NUMBER_OF_TEXTURECOORDS = 0x8
+
+    _fields_ = [ # Bitwise combination of the members of the
             #aiPrimitiveType enum.
             # This specifies which types of primitives are present in the mesh.
             # The "SortByPrimitiveType"-Step can be used to make sure the
@@ -637,17 +745,23 @@ class Mesh(Structure):
             #   - Vertex animations refer to meshes by their names.
             ("mName", String),
             
-            # NOT CURRENTLY IN USE. The number of attachment meshes
+            # The number of attachment meshes. Note! Currently only works with Collada loader.
             ("mNumAnimMeshes", c_uint),
             
-            # NOT CURRENTLY IN USE. Attachment meshes for this mesh, for vertex-based animation.
-            #  Attachment meshes carry replacement data for some of the
-            #  mesh'es vertex components (usually positions, normals).
+            # Attachment meshes for this mesh, for vertex-based animation.
+            # Attachment meshes carry replacement data for some of the
+            # mesh'es vertex components (usually positions, normals).
+            # Note! Currently only works with Collada loader.
+            ("mAnimMesh", POINTER(POINTER(AnimMesh))),
+
+            # Method of morphing when animeshes are specified.
+            ("mMethod", c_uint),
+
         ]
 
 class Camera(Structure):
     """
-    See 'aiCamera.h' for details.
+    See 'camera.h' for details.
     """ 
 
 
@@ -707,7 +821,7 @@ class Camera(Structure):
 
 class VectorKey(Structure):
     """
-    See 'aiAnim.h' for details.
+    See 'anim.h' for details.
     """ 
 
     _fields_ = [
@@ -720,7 +834,7 @@ class VectorKey(Structure):
 
 class QuatKey(Structure):
     """
-    See 'aiAnim.h' for details.
+    See 'anim.h' for details.
     """ 
 
     _fields_ = [
@@ -731,9 +845,27 @@ class QuatKey(Structure):
             ("mValue", Quaternion),
         ]
 
+class MeshMorphKey(Structure):
+    """
+    See 'anim.h' for details.
+    """ 
+
+    _fields_ = [
+            # The time of this key
+            ("mTime", c_double),
+
+            # The values and weights at the time of this key
+            ("mValues", POINTER(c_uint)),
+            ("mWeights", POINTER(c_double)),
+
+            # The number of values and weights
+            ("mNumValuesAndWeights", c_uint),
+
+        ]
+
 class NodeAnim(Structure):
     """
-    See 'aiAnim.h' for details.
+    See 'anim.h' for details.
     """ 
 
     _fields_ = [
@@ -782,9 +914,48 @@ class NodeAnim(Structure):
             ("mPostState", c_uint),
         ]
 
+class MeshAnim(Structure):
+    """
+    See 'anim.h' for details.
+    """ 
+
+    _fields_ = [
+            # Name of the mesh to be animated. An empty string is not allowed,
+            #  animated meshes need to be named (not necessarily uniquely,
+            #  the name can basically serve as wild-card to select a group
+            #  of meshes with similar animation setup)
+            ("mName", String),
+
+            # Size of the #mKeys array. Must be 1, at least.
+            ("mNumKeys", c_uint),
+
+            # Key frames of the animation. May not be NULL.
+            ("mKeys", POINTER(MeshKey)),
+        ]
+
+class MeshMorphAnim(Structure):
+    """
+    See 'anim.h' for details.
+    """     
+
+    _fields_ = [
+            # Name of the mesh to be animated. An empty string is not allowed,
+            # animated meshes need to be named (not necessarily uniquely,
+            # the name can basically serve as wildcard to select a group
+            # of meshes with similar animation setup)
+            ("mName", String),
+
+            # Size of the #mKeys array. Must be 1, at least.
+            ("mNumKeys", c_uint),
+
+            # Key frames of the animation. May not be NULL.
+            ("mKeys", POINTER(MeshMorphKey)),
+        ]
+
+
 class Animation(Structure):
     """
-    See 'aiAnim.h' for details.
+    See 'anim.h' for details.
     """ 
 
     _fields_ = [
@@ -813,6 +984,16 @@ class Animation(Structure):
             
             # The mesh animation channels. Each channel affects a single mesh.
             #  The array is mNumMeshChannels in size.
+            ("mMeshChannels", POINTER(POINTER(MeshAnim))),
+
+            # The number of mesh animation channels. Each channel affects
+            # a single mesh and defines morphing animation.
+            ("mNumMorphMeshChannels", c_uint),
+
+            # The morph mesh animation channels. Each channel affects a single mesh.
+            # The array is mNumMorphMeshChannels in size. 
+            ("mMorphMeshChannels", POINTER(POINTER(MeshMorphAnim))),
+
         ]
 
 class Scene(Structure):
@@ -820,11 +1001,12 @@ class Scene(Structure):
     See 'aiScene.h' for details.
     """ 
 
-    AI_SCENE_FLAGS_INCOMPLETE = 0x1
-    AI_SCENE_FLAGS_VALIDATED = 0x2
-    AI_SCENE_FLAGS_VALIDATION_WARNING =  	0x4
-    AI_SCENE_FLAGS_NON_VERBOSE_FORMAT =  	0x8
-    AI_SCENE_FLAGS_TERRAIN = 0x10
+    AI_SCENE_FLAGS_INCOMPLETE = 0x1
+    AI_SCENE_FLAGS_VALIDATED = 0x2
+    AI_SCENE_FLAGS_VALIDATION_WARNING =  	0x4
+    AI_SCENE_FLAGS_NON_VERBOSE_FORMAT =  	0x8
+    AI_SCENE_FLAGS_TERRAIN = 0x10
+    AI_SCENE_FLAGS_ALLOW_SHARED = 0x20
 
     _fields_ = [
             # Any combination of the AI_SCENE_FLAGS_XXX flags. By default
@@ -896,6 +1078,14 @@ class Scene(Structure):
             # array (if existing) is the default camera view into
             # the scene.
             ("mCameras", POINTER(POINTER(Camera))),
+
+            # This data contains global metadata which belongs to the scene like
+            # unit-conversions, versions, vendors or other model-specific data. This
+            # can be used to store format-specific metadata as well.
+            ("mMetadata", POINTER(Metadata)),
+
+            # Internal data, do not touch
+            ("mPrivate", c_char_p),
         ]
 
 assimp_structs_as_tuple = (Matrix4x4,

scripts/StepImporter/schema_ap203e2_mim_lf.exp

@@ -0,0 +1,16378 @@
+(*
+  $Id: mim_lf.exp,v 1.43 2009/09/10 20:08:09 darla Exp $
+  ISO TC184/SC4/WG3 N2635 - ISO/TS 10303-403 AP203 configuration controlled 3d design of mechanical parts and assemblies - EXPRESS MIM Long form 
+  Supersedes ISO TC184/SC4/WG3 N2464
+*) 
+
+SCHEMA Ap203_configuration_controlled_3d_design_of_mechanical_parts_and_assemblies_mim_lf;
+
+
+CONSTANT
+	deprecated_constructed_data_types : SET [0:?] OF STRING := ['approved_item',
+       'certified_item', 
+       'change_request_item', 
+       'contracted_item', 
+       'cc_classified_item', 
+       'date_time_item', 
+       'cc_person_organization_item', 
+       'cc_specified_item', 
+       'start_request_item', 
+       'work_item'];
+
+
+	deprecated_entity_data_types : SET [0:?] OF STRING := ['cc_design_approval',
+       'cc_design_certification', 
+       'cc_design_contract', 
+       'cc_design_date_and_time_assignment', 
+       'cc_design_person_and_organization_assignment', 
+       'cc_design_security_classification', 
+       'cc_design_specification_reference', 
+       'change', 
+       'change_request', 
+       'design_context', 
+       'design_make_from_relationship', 
+       'mechanical_context', 
+       'start_request', 
+       'start_work', 
+       'supplied_part_relationship'];
+
+
+	deprecated_interfaced_data_types : SET [0:?] OF STRING := ['document_with_class',
+       'ordinal_date', 
+       'product_definition_formation_with_specified_source', 
+       'week_of_year_and_day_date'];
+
+
+	dummy_gri : geometric_representation_item := representation_item('')||
+                                   geometric_representation_item();
+
+
+	dummy_tri : topological_representation_item := representation_item('')||
+                   topological_representation_item();
+
+
+	pre_defined_picture_representation_types : SET [0:?] OF STRING := [ 'JPEG', 'PNG', 'TIFF', 'BMP', 'GIF'];
+
+
+
+END_CONSTANT;
+
+TYPE absorbed_dose_measure = REAL;
+END_TYPE;
+
+TYPE acceleration_measure = REAL;
+END_TYPE;
+
+TYPE action_items = SELECT (
+	action_directive,
+	certification_item,
+	characterized_object,
+	classification_item,
+	configuration_effectivity,
+	document_reference_item,
+	identification_item,
+	organization,
+	person_and_organization,
+	product_definition,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	requirement_assigned_item);
+END_TYPE;
+
+TYPE action_method_items = SELECT (
+	product,
+	product_definition_formation);
+END_TYPE;
+
+TYPE action_request_item = SELECT (
+	product_definition,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	property_definition,
+	versioned_action_request);
+END_TYPE;
+
+TYPE ahead_or_behind = ENUMERATION OF (
+	ahead,
+	exact,
+	behind );
+END_TYPE;
+
+TYPE amount_of_substance_measure = REAL;
+END_TYPE;
+
+TYPE angle_direction_reference_select = SELECT (
+	direction,
+	curve,
+	point_path);
+END_TYPE;
+
+TYPE angle_direction_reference_with_a2p3d_select = SELECT (
+	angle_direction_reference_select,
+	axis2_placement_3d);
+END_TYPE;
+
+TYPE angle_relator = ENUMERATION OF (
+	equal,
+	large,
+	small );
+END_TYPE;
+
+TYPE annotation_plane_element = SELECT (
+	draughting_callout,
+	styled_item);
+END_TYPE;
+
+TYPE annotation_representation_select = SELECT (
+	presentation_area,
+	presentation_view,
+	symbol_representation);
+END_TYPE;
+
+TYPE annotation_symbol_occurrence_item = SELECT (
+	annotation_symbol,
+	defined_symbol);
+END_TYPE;
+
+TYPE annotation_text_occurrence_item = SELECT (
+	text_literal,
+	annotation_text,
+	annotation_text_character,
+	composite_text);
+END_TYPE;
+
+TYPE approval_item = SELECT (
+	action,
+	action_directive,
+	alternate_product_relationship,
+	applied_action_assignment,
+	applied_usage_right,
+	assembly_component_usage_substitute,
+	certification,
+	configuration_effectivity,
+	configuration_item,
+	contract,
+	date,
+	directed_action,
+	document,
+	document_file,
+	effectivity,
+	executed_action,
+	general_property_relationship,
+	group,
+	group_relationship,
+	information_usage_right,
+	product,
+	product_definition,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	representation,
+	requirement_assignment,
+	security_classification,
+	shape_aspect_relationship,
+	versioned_action_request);
+END_TYPE;
+
+TYPE approved_item = SELECT (
+	certification,
+	change,
+	change_request,
+	configuration_effectivity,
+	configuration_item,
+	contract,
+	product,
+	security_classification,
+	start_request,
+	start_work);
+END_TYPE;
+
+TYPE area_measure = REAL;
+END_TYPE;
+
+TYPE area_or_view = SELECT (
+	presentation_area,
+	presentation_view);
+END_TYPE;
+
+TYPE attribute_classification_item = SELECT (
+	action_directive,
+	action_method,
+	action_property,
+	action_property_representation,
+	action_relationship,
+	action_request_solution,
+	action_request_status,
+	alternate_product_relationship,
+	applied_action_assignment,
+	applied_action_request_assignment,
+	applied_approval_assignment,
+	applied_certification_assignment,
+	applied_document_reference,
+	applied_document_usage_constraint_assignment,
+	applied_effectivity_assignment,
+	applied_event_occurrence_assignment,
+	applied_external_identification_assignment,
+	applied_identification_assignment,
+	applied_organization_assignment,
+	applied_organizational_project_assignment,
+	applied_person_and_organization_assignment,
+	approval,
+	approval_person_organization,
+	approval_relationship,
+	approval_status,
+	certification,
+	context_dependent_unit,
+	contract,
+	date_and_time_assignment,
+	date_assignment,
+	derived_unit,
+	descriptive_representation_item,
+	document_file,
+	document_relationship,
+	effectivity,
+	event_occurrence_relationship,
+	executed_action,
+	general_property,
+	general_property_relationship,
+	group,
+	group_relationship,
+	information_right,
+	information_usage_right,
+	language,
+	measure_representation_item,
+	measure_with_unit,
+	named_unit,
+	organization_relationship,
+	organizational_address,
+	organizational_project_relationship,
+	person_and_organization,
+	person_and_organization_address,
+	product,
+	product_category,
+	product_concept,
+	product_concept_context,
+	product_definition,
+	product_definition_context,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	property_definition,
+	property_definition_relationship,
+	property_definition_representation,
+	representation,
+	representation_context,
+	representation_item,
+	security_classification,
+	time_interval_relationship,
+	uncertainty_measure_with_unit,
+	usage_association,
+	versioned_action_request);
+END_TYPE;
+
+TYPE attribute_language_item = SELECT (
+	alternate_product_relationship,
+	application_context,
+	applied_certification_assignment,
+	applied_document_reference,
+	applied_document_usage_constraint_assignment,
+	applied_external_identification_assignment,
+	applied_identification_assignment,
+	applied_organizational_project_assignment,
+	applied_security_classification_assignment,
+	approval,
+	approval_relationship,
+	approval_status,
+	assembly_component_usage_substitute,
+	attribute_value_assignment,
+	certification,
+	certification_type,
+	configuration_design,
+	configuration_item,
+	contract,
+	date_role,
+	date_time_role,
+	descriptive_representation_item,
+	document_relationship,
+	document_usage_role,
+	effectivity,
+	effectivity_relationship,
+	event_occurrence,
+	external_source,
+	general_property,
+	general_property_relationship,
+	geometric_representation_item,
+	geometric_tolerance,
+	identification_role,
+	information_right,
+	information_usage_right,
+	make_from_usage_option,
+	mapped_item,
+	multi_language_attribute_assignment,
+	object_role,
+	organization_relationship,
+	organization_role,
+	organizational_project,
+	organizational_project_relationship,
+	organizational_project_role,
+	person_and_organization,
+	person_and_organization_role,
+	product,
+	product_concept,
+	product_concept_relationship,
+	product_definition,
+	product_definition_context,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	product_definition_shape,
+	product_related_product_category,
+	property_definition,
+	representation,
+	security_classification,
+	security_classification_assignment,
+	shape_aspect,
+	shape_aspect_relationship,
+	shape_representation,
+	time_interval_role,
+	topological_representation_item,
+	uncertainty_measure_with_unit,
+	uncertainty_qualifier,
+	usage_association);
+END_TYPE;
+
+TYPE attribute_type = SELECT (
+	label,
+	text);
+END_TYPE;
+
+TYPE axis2_placement = SELECT (
+	axis2_placement_2d,
+	axis2_placement_3d);
+END_TYPE;
+
+TYPE b_spline_curve_form = ENUMERATION OF (
+	polyline_form,
+	circular_arc,
+	elliptic_arc,
+	parabolic_arc,
+	hyperbolic_arc,
+	unspecified );
+END_TYPE;
+
+TYPE b_spline_surface_form = ENUMERATION OF (
+	plane_surf,
+	cylindrical_surf,
+	conical_surf,
+	spherical_surf,
+	toroidal_surf,
+	surf_of_revolution,
+	ruled_surf,
+	generalised_cone,
+	quadric_surf,
+	surf_of_linear_extrusion,
+	unspecified );
+END_TYPE;
+
+TYPE base_solid_select = SELECT (
+	solid_model,
+	csg_primitive,
+	boolean_result);
+WHERE
+	WR1 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRIMITIVE_2D' IN TYPEOF(SELF));
+END_TYPE;
+
+TYPE blend_end_condition_select = SELECT (
+	point_on_curve,
+	edge_curve,
+	vertex);
+END_TYPE;
+
+TYPE blend_radius_variation_type = ENUMERATION OF (
+	linear_blend,
+	cubic_blend,
+	unspecified_blend );
+END_TYPE;
+
+TYPE boolean_operand = SELECT (
+	solid_model,
+	half_space_solid,
+	csg_primitive,
+	boolean_result);
+END_TYPE;
+
+TYPE boolean_operator = ENUMERATION OF (
+	union,
+	intersection,
+	difference );
+END_TYPE;
+
+TYPE box_characteristic_select = SELECT (
+	box_height,
+	box_width,
+	box_slant_angle,
+	box_rotate_angle);
+END_TYPE;
+
+TYPE box_height = positive_ratio_measure;
+END_TYPE;
+
+TYPE box_rotate_angle = plane_angle_measure;
+END_TYPE;
+
+TYPE box_slant_angle = plane_angle_measure;
+END_TYPE;
+
+TYPE box_width = positive_ratio_measure;
+END_TYPE;
+
+TYPE camera_model_d3_multi_clipping_interection_select = SELECT (
+	camera_model_d3_multi_clipping_union,
+	plane);
+END_TYPE;
+
+TYPE camera_model_d3_multi_clipping_union_select = SELECT (
+	camera_model_d3_multi_clipping_intersection,
+	plane);
+END_TYPE;
+
+TYPE capacitance_measure = REAL;
+END_TYPE;
+
+TYPE category_usage_item = SELECT (
+	product_class);
+END_TYPE;
+
+TYPE cc_classified_item = SELECT (
+	assembly_component_usage,
+	product_definition_formation);
+END_TYPE;
+
+TYPE cc_person_organization_item = SELECT (
+	change,
+	change_request,
+	configuration_item,
+	contract,
+	product,
+	product_definition,
+	product_definition_formation,
+	security_classification,
+	start_request,
+	start_work);
+END_TYPE;
+
+TYPE cc_specified_item = SELECT (
+	product_definition,
+	shape_aspect);
+END_TYPE;
+
+TYPE celsius_temperature_measure = REAL;
+END_TYPE;
+
+TYPE central_or_parallel = ENUMERATION OF (
+	central,
+	parallel );
+END_TYPE;
+
+TYPE certification_item = SELECT (
+	alternate_product_relationship,
+	make_from_usage_option,
+	product_definition_formation,
+	product_definition_formation_relationship);
+END_TYPE;
+
+TYPE certified_item = SELECT (
+	supplied_part_relationship);
+END_TYPE;
+
+TYPE change_request_item = SELECT (
+	product_definition_formation);
+END_TYPE;
+
+TYPE character_spacing_select = SELECT (
+	length_measure,
+	ratio_measure,
+	measure_with_unit,
+	descriptive_measure);
+END_TYPE;
+
+TYPE character_style_select = SELECT (
+	character_glyph_style_stroke,
+	character_glyph_style_outline,
+	text_style_for_defined_font);
+END_TYPE;
+
+TYPE characterized_action_definition = SELECT (
+	action,
+	action_method,
+	action_method_relationship,
+	action_relationship);
+END_TYPE;
+
+TYPE characterized_definition = SELECT (
+	characterized_object,
+	characterized_product_definition,
+	shape_definition);
+END_TYPE;
+
+TYPE characterized_material_property = SELECT (
+	material_property_representation,
+	product_material_composition_relationship);
+END_TYPE;
+
+TYPE characterized_product_composition_value = SELECT (
+	measure_with_unit);
+END_TYPE;
+
+TYPE characterized_product_definition = SELECT (
+	product_definition,
+	product_definition_relationship);
+END_TYPE;
+
+TYPE class_usage_effectivity_context_item = SELECT (
+	product_definition);
+END_TYPE;
+
+TYPE classification_item = SELECT (
+	action,
+	action_directive,
+	action_method,
+	action_property,
+	action_relationship,
+	action_request_solution,
+	action_request_status,
+	address,
+	alternate_product_relationship,
+	applied_action_assignment,
+	applied_action_request_assignment,
+	applied_approval_assignment,
+	applied_certification_assignment,
+	applied_contract_assignment,
+	applied_date_and_time_assignment,
+	applied_date_assignment,
+	applied_document_reference,
+	applied_document_usage_constraint_assignment,
+	applied_effectivity_assignment,
+	applied_event_occurrence_assignment,
+	applied_external_identification_assignment,
+	applied_identification_assignment,
+	applied_organization_assignment,
+	applied_organizational_project_assignment,
+	applied_person_and_organization_assignment,
+	applied_security_classification_assignment,
+	approval,
+	approval_person_organization,
+	approval_relationship,
+	approval_status,
+	assembly_component_usage_substitute,
+	calendar_date,
+	certification,
+	characterized_class,
+	characterized_object,
+	class,
+	classified_item,
+	configuration_item,
+	context_dependent_unit,
+	contract,
+	conversion_based_unit,
+	date_and_time,
+	date_and_time_assignment,
+	date_assignment,
+	derived_unit,
+	descriptive_representation_item,
+	directed_action,
+	document_file,
+	document_relationship,
+	effectivity,
+	event_occurrence,
+	executed_action,
+	general_property,
+	general_property_relationship,
+	group,
+	identification_assignment,
+	information_right,
+	information_usage_right,
+	language,
+	measure_representation_item,
+	measure_with_unit,
+	multi_language_attribute_assignment,
+	named_unit,
+	organization,
+	organization_relationship,
+	organizational_address,
+	organizational_project,
+	organizational_project_relationship,
+	person,
+	person_and_organization_address,
+	product,
+	product_concept,
+	product_definition,
+	product_definition_context,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	property_definition,
+	property_definition_representation,
+	representation,
+	representation_context,
+	representation_item,
+	security_classification,
+	uncertainty_measure_with_unit,
+	usage_association,
+	versioned_action_request);
+END_TYPE;
+
+TYPE classified_item = SELECT (
+	product,
+	product_definition,
+	product_definition_formation);
+END_TYPE;
+
+TYPE compound_item_definition = SELECT (
+	list_representation_item,
+	set_representation_item);
+END_TYPE;
+
+TYPE conductance_measure = REAL;
+END_TYPE;
+
+TYPE configuration_design_item = SELECT (
+	product_definition,
+	product_definition_formation);
+END_TYPE;
+
+TYPE configured_effectivity_context_item = SELECT (
+	product_concept_feature_association);
+END_TYPE;
+
+TYPE configured_effectivity_item = SELECT (
+	product_definition);
+END_TYPE;
+
+TYPE constructive_geometry_representation_or_shape_represenation = SELECT (
+	constructive_geometry_representation,
+	shape_representation);
+END_TYPE;
+
+TYPE context_dependent_measure = REAL;
+END_TYPE;
+
+TYPE contract_item = SELECT (
+	action_directive,
+	alternate_product_relationship,
+	directed_action,
+	executed_action,
+	information_usage_right,
+	organization,
+	person_and_organization,
+	product,
+	product_definition_formation);
+END_TYPE;
+
+TYPE contracted_item = SELECT (
+	product_definition_formation);
+END_TYPE;
+
+TYPE count_measure = NUMBER;
+END_TYPE;
+
+TYPE csg_primitive = SELECT (
+	sphere,
+	block,
+	right_angular_wedge,
+	torus,
+	right_circular_cone,
+	right_circular_cylinder);
+END_TYPE;
+
+TYPE csg_select = SELECT (
+	boolean_result,
+	csg_primitive);
+END_TYPE;
+
+TYPE curve_font_or_scaled_curve_font_select = SELECT (
+	curve_style_font_select,
+	curve_style_font_and_scaling);
+END_TYPE;
+
+TYPE curve_on_surface = SELECT (
+	pcurve,
+	surface_curve,
+	composite_curve_on_surface);
+END_TYPE;
+
+TYPE curve_or_annotation_curve_occurrence = SELECT (
+	curve,
+	annotation_curve_occurrence);
+END_TYPE;
+
+TYPE curve_or_render = SELECT (
+	curve_style,
+	curve_style_rendering);
+END_TYPE;
+
+TYPE curve_style_font_select = SELECT (
+	curve_style_font,
+	pre_defined_curve_font,
+	externally_defined_curve_font);
+END_TYPE;
+
+TYPE date_and_time_item = SELECT (
+	action,
+	action_directive,
+	applied_action_assignment,
+	applied_organization_assignment,
+	applied_person_and_organization_assignment,
+	applied_security_classification_assignment,
+	approval_person_organization,
+	certification,
+	contract,
+	directed_action,
+	document,
+	document_file,
+	event_occurrence,
+	executed_action,
+	information_usage_right,
+	organizational_project,
+	product_definition,
+	product_definition_formation,
+	product_definition_relationship,
+	rule_action,
+	security_classification,
+	versioned_action_request);
+END_TYPE;
+
+TYPE date_item = SELECT (
+	action,
+	action_directive,
+	applied_action_assignment,
+	applied_organization_assignment,
+	applied_person_and_organization_assignment,
+	applied_security_classification_assignment,
+	approval_person_organization,
+	certification,
+	contract,
+	directed_action,
+	document,
+	document_file,
+	event_occurrence,
+	executed_action,
+	information_usage_right,
+	organizational_project,
+	product_definition,
+	product_definition_formation,
+	product_definition_relationship,
+	security_classification,
+	versioned_action_request);
+END_TYPE;
+
+TYPE date_time_item = SELECT (
+	approval_person_organization,
+	certification,
+	change,
+	change_request,
+	contract,
+	product_definition,
+	security_classification,
+	start_request,
+	start_work);
+END_TYPE;
+
+TYPE date_time_or_event_occurrence = SELECT (
+	date_time_select,
+	event_occurrence);
+END_TYPE;
+
+TYPE date_time_select = SELECT (
+	date,
+	date_and_time,
+	local_time);
+END_TYPE;
+
+TYPE day_in_month_number = INTEGER;
+WHERE
+	WR1 : {1 <= SELF <= 31};
+END_TYPE;
+
+TYPE day_in_week_number = INTEGER;
+WHERE
+	WR1 : { 1 <= SELF <= 7 };
+END_TYPE;
+
+TYPE day_in_year_number = INTEGER;
+WHERE
+	WR1 : {1 <= SELF <= 366};
+END_TYPE;
+
+TYPE defined_symbol_select = SELECT (
+	pre_defined_symbol,
+	externally_defined_symbol);
+END_TYPE;
+
+TYPE derived_property_select = SELECT (
+	property_definition,
+	action_property);
+END_TYPE;
+
+TYPE description_attribute_select = SELECT (
+	action_request_solution,
+	application_context,
+	approval_role,
+	configuration_design,
+	date_role,
+	date_time_role,
+	context_dependent_shape_representation,
+	effectivity,
+	external_source,
+	organization_role,
+	person_and_organization_role,
+	person_and_organization,
+	property_definition_representation,
+	representation);
+END_TYPE;
+
+TYPE descriptive_measure = STRING;
+END_TYPE;
+
+TYPE dimension_count = INTEGER;
+WHERE
+	WR1 : SELF > 0;
+END_TYPE;
+
+TYPE dimension_extent_usage = ENUMERATION OF (
+	origin,
+	target );
+END_TYPE;
+
+TYPE dimensional_characteristic = SELECT (
+	dimensional_location,
+	dimensional_size);
+END_TYPE;
+
+TYPE direction_count_select = SELECT (
+	u_direction_count,
+	v_direction_count);
+END_TYPE;
+
+TYPE document_identifier_assigned_item = SELECT (
+	document);
+END_TYPE;
+
+TYPE document_reference_item = SELECT (
+	action_method,
+	applied_external_identification_assignment,
+	assembly_component_usage,
+	characterized_class,
+	characterized_object,
+	configuration_item,
+	descriptive_representation_item,
+	dimensional_size,
+	executed_action,
+	externally_defined_dimension_definition,
+	externally_defined_item,
+	group,
+	group_relationship,
+	information_right,
+	information_usage_right,
+	material_designation,
+	measure_representation_item,
+	product,
+	product_category,
+	product_definition,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	property_definition,
+	representation,
+	representation_item,
+	rule_set,
+	shape_aspect,
+	shape_aspect_relationship,
+	usage_association,
+	versioned_action_request);
+END_TYPE;
+
+TYPE dose_equivalent_measure = REAL;
+END_TYPE;
+
+TYPE draughting_callout_element = SELECT (
+	annotation_text_occurrence,
+	annotation_symbol_occurrence,
+	annotation_curve_occurrence);
+END_TYPE;
+
+TYPE draughting_model_item_association_select = SELECT (
+	annotation_occurrence,
+	draughting_callout);
+END_TYPE;
+
+TYPE draughting_model_item_select = SELECT (
+	mapped_item,
+	styled_item,
+	axis2_placement,
+	camera_model,
+	draughting_callout);
+END_TYPE;
+
+TYPE draughting_titled_item = SELECT (
+	drawing_revision,
+	drawing_sheet_revision);
+END_TYPE;
+
+TYPE effectivity_item = SELECT (
+	assembly_component_usage_substitute,
+	product,
+	product_definition,
+	product_definition_formation,
+	product_definition_relationship,
+	product_definition_substitute);
+END_TYPE;
+
+TYPE electric_charge_measure = REAL;
+END_TYPE;
+
+TYPE electric_current_measure = REAL;
+END_TYPE;
+
+TYPE electric_potential_measure = REAL;
+END_TYPE;
+
+TYPE energy_measure = REAL;
+END_TYPE;
+
+TYPE event_occurrence_item = SELECT (
+	organizational_project);
+END_TYPE;
+
+TYPE external_identification_item = SELECT (
+	action_relationship,
+	action_request_status,
+	applied_organization_assignment,
+	applied_person_and_organization_assignment,
+	approval,
+	approval_status,
+	date_and_time_assignment,
+	date_assignment,
+	document_file,
+	external_source,
+	externally_defined_class,
+	externally_defined_context_dependent_unit,
+	externally_defined_conversion_based_unit,
+	externally_defined_general_property,
+	externally_defined_picture_representation_item,
+	externally_defined_representation_item,
+	organizational_address,
+	product_definition,
+	security_classification,
+	trimmed_curve,
+	versioned_action_request);
+END_TYPE;
+
+TYPE fill_area_style_tile_shape_select = SELECT (
+	fill_area_style_tile_curve_with_style,
+	fill_area_style_tile_coloured_region,
+	fill_area_style_tile_symbol_with_style,
+	pre_defined_tile,
+	externally_defined_tile);
+END_TYPE;
+
+TYPE fill_style_select = SELECT (
+	fill_area_style_colour,
+	externally_defined_tile_style,
+	fill_area_style_tiles,
+	externally_defined_hatch_style,
+	fill_area_style_hatching);
+END_TYPE;
+
+TYPE font_select = SELECT (
+	pre_defined_text_font,
+	externally_defined_text_font,
+	text_font);
+END_TYPE;
+
+TYPE force_measure = REAL;
+END_TYPE;
+
+TYPE founded_item_select = SELECT (
+	founded_item,
+	representation_item);
+END_TYPE;
+
+TYPE frequency_measure = REAL;
+END_TYPE;
+
+TYPE generalized_surface_select = SELECT (
+	surface,
+	face_surface,
+	surfaced_open_shell);
+END_TYPE;
+
+TYPE geometric_item_specific_usage_select = SELECT (
+	shape_aspect,
+	shape_aspect_relationship);
+END_TYPE;
+
+TYPE geometric_set_select = SELECT (
+	point,
+	curve,
+	surface);
+END_TYPE;
+
+TYPE groupable_item = SELECT (
+	geometric_representation_item,
+	group_relationship,
+	mapped_item,
+	package_product_concept_feature,
+	product_concept_feature,
+	product_definition,
+	product_definition_formation,
+	property_definition_representation,
+	representation,
+	representation_item,
+	representation_relationship_with_transformation,
+	shape_aspect,
+	shape_aspect_relationship,
+	shape_representation_relationship,
+	styled_item,
+	topological_representation_item);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GROUP' IN TYPEOF(SELF));
+END_TYPE;
+
+TYPE hour_in_day = INTEGER;
+WHERE
+	WR1 : { 0 <= SELF < 24 };
+END_TYPE;
+
+TYPE id_attribute_select = SELECT (
+	action,
+	address,
+	product_category,
+	property_definition,
+	shape_aspect,
+	shape_aspect_relationship,
+	application_context,
+	group,
+	organizational_project,
+	representation);
+END_TYPE;
+
+TYPE identification_item = SELECT (
+	approval_status,
+	characterized_class,
+	class,
+	configuration_item,
+	contract,
+	dimensional_size,
+	document_file,
+	general_property,
+	group,
+	group_relationship,
+	information_right,
+	information_usage_right,
+	material_designation,
+	organization,
+	person_and_organization,
+	product,
+	product_category,
+	product_class,
+	product_concept,
+	product_concept_feature,
+	product_definition,
+	product_definition_formation,
+	product_identification,
+	representation,
+	rule_set,
+	security_classification,
+	security_classification_level,
+	shape_aspect_relationship,
+	shape_representation,
+	usage_association);
+END_TYPE;
+
+TYPE identifier = STRING;
+END_TYPE;
+
+TYPE illuminance_measure = REAL;
+END_TYPE;
+
+TYPE inductance_measure = REAL;
+END_TYPE;
+
+TYPE instance_usage_context_select = SELECT (
+	product_definition_relationship,
+	product_definition_usage);
+END_TYPE;
+
+TYPE invisibility_context = SELECT (
+	draughting_model,
+	presentation_representation,
+	presentation_set);
+END_TYPE;
+
+TYPE invisible_item = SELECT (
+	draughting_callout,
+	presentation_layer_assignment,
+	representation,
+	styled_item);
+END_TYPE;
+
+TYPE ir_usage_item = action_items;
+WHERE
+	wr1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONFIGURATION_EFFECTIVITY' IN TYPEOF(SELF));
+END_TYPE;
+
+TYPE knot_type = ENUMERATION OF (
+	uniform_knots,
+	quasi_uniform_knots,
+	piecewise_bezier_knots,
+	unspecified );
+END_TYPE;
+
+TYPE label = STRING;
+END_TYPE;
+
+TYPE layered_item = SELECT (
+	presentation_representation,
+	representation_item);
+END_TYPE;
+
+TYPE length_measure = REAL;
+END_TYPE;
+
+TYPE limit_condition = ENUMERATION OF (
+	maximum_material_condition,
+	least_material_condition,
+	regardless_of_feature_size );
+END_TYPE;
+
+TYPE list_of_reversible_topology_item = LIST [0:?] OF reversible_topology_item;
+END_TYPE;
+
+TYPE list_representation_item = LIST [1:?] OF representation_item;
+END_TYPE;
+
+TYPE luminous_flux_measure = REAL;
+END_TYPE;
+
+TYPE luminous_intensity_measure = REAL;
+END_TYPE;
+
+TYPE magnetic_flux_density_measure = REAL;
+END_TYPE;
+
+TYPE magnetic_flux_measure = REAL;
+END_TYPE;
+
+TYPE marker_select = SELECT (
+	marker_type,
+	pre_defined_marker);
+END_TYPE;
+
+TYPE marker_type = ENUMERATION OF (
+	dot,
+	x,
+	plus,
+	asterisk,
+	ring,
+	square,
+	triangle );
+END_TYPE;
+
+TYPE mass_measure = REAL;
+END_TYPE;
+
+TYPE measure_value = SELECT (
+	absorbed_dose_measure,
+	dose_equivalent_measure,
+	radioactivity_measure,
+	acceleration_measure,
+	amount_of_substance_measure,
+	area_measure,
+	celsius_temperature_measure,
+	context_dependent_measure,
+	count_measure,
+	descriptive_measure,
+	capacitance_measure,
+	electric_charge_measure,
+	conductance_measure,
+	electric_current_measure,
+	electric_potential_measure,
+	energy_measure,
+	magnetic_flux_density_measure,
+	force_measure,
+	frequency_measure,
+	illuminance_measure,
+	inductance_measure,
+	length_measure,
+	luminous_flux_measure,
+	luminous_intensity_measure,
+	magnetic_flux_measure,
+	mass_measure,
+	numeric_measure,
+	non_negative_length_measure,
+	parameter_value,
+	plane_angle_measure,
+	positive_length_measure,
+	positive_plane_angle_measure,
+	positive_ratio_measure,
+	power_measure,
+	pressure_measure,
+	ratio_measure,
+	resistance_measure,
+	solid_angle_measure,
+	thermodynamic_temperature_measure,
+	time_measure,
+	velocity_measure,
+	volume_measure);
+END_TYPE;
+
+TYPE mechanical_design_and_draughting_relationship_select = SELECT (
+	draughting_model,
+	mechanical_design_geometric_presentation_representation,
+	mechanical_design_presentation_representation_with_draughting,
+	mechanical_design_shaded_presentation_representation,
+	shape_representation);
+END_TYPE;
+
+TYPE mechanical_design_geometric_presentation_area_items = SELECT (
+	axis2_placement,
+	mapped_item);
+END_TYPE;
+
+TYPE mechanical_design_geometric_presentation_representation_items = SELECT (
+	axis2_placement,
+	camera_model_d3,
+	mapped_item,
+	styled_item);
+END_TYPE;
+
+TYPE message = STRING;
+END_TYPE;
+
+TYPE minute_in_hour = INTEGER;
+WHERE
+	WR1 : { 0 <= SELF <= 59 };
+END_TYPE;
+
+TYPE month_in_year_number = INTEGER;
+WHERE
+	WR1 : { 1 <= SELF <= 12 };
+END_TYPE;
+
+TYPE multi_language_attribute_item = SELECT (
+	alternate_product_relationship,
+	application_context,
+	applied_certification_assignment,
+	applied_document_reference,
+	applied_document_usage_constraint_assignment,
+	applied_external_identification_assignment,
+	applied_identification_assignment,
+	applied_organizational_project_assignment,
+	approval,
+	approval_relationship,
+	approval_status,
+	assembly_component_usage_substitute,
+	attribute_value_assignment,
+	certification,
+	certification_type,
+	colour,
+	configuration_design,
+	configuration_item,
+	contract,
+	date_role,
+	date_time_role,
+	descriptive_representation_item,
+	document_relationship,
+	document_usage_role,
+	effectivity,
+	effectivity_relationship,
+	event_occurrence,
+	external_source,
+	general_property,
+	general_property_relationship,
+	geometric_representation_item,
+	geometric_tolerance,
+	identification_role,
+	information_right,
+	information_usage_right,
+	make_from_usage_option,
+	mapped_item,
+	object_role,
+	organization_relationship,
+	organization_role,
+	organizational_project,
+	organizational_project_relationship,
+	organizational_project_role,
+	person_and_organization,
+	person_and_organization_role,
+	product,
+	product_concept,
+	product_concept_relationship,
+	product_definition,
+	product_definition_context,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	product_definition_shape,
+	product_related_product_category,
+	property_definition,
+	representation,
+	representation_relationship,
+	security_classification,
+	security_classification_assignment,
+	shape_aspect,
+	shape_aspect_relationship,
+	shape_representation,
+	time_interval_role,
+	topological_representation_item,
+	uncertainty_measure_with_unit,
+	usage_association);
+END_TYPE;
+
+TYPE name_attribute_select = SELECT (
+	action_request_solution,
+	address,
+	configuration_design,
+	context_dependent_shape_representation,
+	derived_unit,
+	effectivity,
+	person_and_organization,
+	product_definition,
+	product_definition_substitute,
+	property_definition_representation);
+END_TYPE;
+
+TYPE name_item = SELECT (
+	assembly_component_usage,
+	external_class_library,
+	group,
+	group_relationship,
+	product,
+	product_definition);
+END_TYPE;
+
+TYPE non_negative_length_measure = length_measure;
+WHERE
+	WR1 : SELF >= 0.0;
+END_TYPE;
+
+TYPE nonnegative_integer = INTEGER;
+WHERE
+	nonnegativity : SELF >= 0;
+END_TYPE;
+
+TYPE null_style = ENUMERATION OF (
+	null );
+END_TYPE;
+
+TYPE numeric_measure = NUMBER;
+END_TYPE;
+
+TYPE organization_item = SELECT (
+	action,
+	action_directive,
+	alternate_product_relationship,
+	applied_action_assignment,
+	applied_classification_assignment,
+	applied_identification_assignment,
+	applied_security_classification_assignment,
+	approval,
+	assembly_component_usage_substitute,
+	certification,
+	class,
+	configuration_item,
+	contract,
+	document_file,
+	executed_action,
+	general_property,
+	information_usage_right,
+	organizational_project,
+	product,
+	product_definition,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	property_definition,
+	rule_action,
+	security_classification,
+	shape_representation,
+	versioned_action_request);
+END_TYPE;
+
+TYPE orientation_basis_select = SELECT (
+	axis2_placement_3d,
+	min_and_major_ply_orientation_basis);
+END_TYPE;
+
+TYPE parameter_value = REAL;
+END_TYPE;
+
+TYPE pcurve_or_surface = SELECT (
+	pcurve,
+	surface);
+END_TYPE;
+
+TYPE person_and_organization_item = SELECT (
+	action,
+	action_directive,
+	alternate_product_relationship,
+	applied_action_assignment,
+	applied_classification_assignment,
+	applied_identification_assignment,
+	applied_security_classification_assignment,
+	approval,
+	assembly_component_usage_substitute,
+	certification,
+	configuration_item,
+	contract,
+	document_file,
+	executed_action,
+	general_property,
+	information_usage_right,
+	organizational_project,
+	person_and_organization,
+	product,
+	product_definition,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	property_definition,
+	rule_action,
+	security_classification,
+	shape_representation,
+	versioned_action_request);
+END_TYPE;
+
+TYPE person_organization_select = SELECT (
+	person,
+	organization,
+	person_and_organization);
+END_TYPE;
+
+TYPE picture_representation_item_select = SELECT (
+	styled_item,
+	planar_box,
+	axis2_placement_2d);
+END_TYPE;
+
+TYPE plane_angle_measure = REAL;
+END_TYPE;
+
+TYPE plane_or_planar_box = SELECT (
+	plane,
+	planar_box);
+END_TYPE;
+
+TYPE point_and_vector_member = SELECT (
+	point,
+	direction);
+END_TYPE;
+
+TYPE point_and_vector_members = LIST [2:3] OF point_and_vector_member;
+END_TYPE;
+
+TYPE point_path_members = LIST [1:?] OF point_and_vector;
+END_TYPE;
+
+TYPE positive_integer = nonnegative_integer;
+WHERE
+	positivity : SELF > 0;
+END_TYPE;
+
+TYPE positive_length_measure = non_negative_length_measure;
+WHERE
+	WR1 : SELF > 0.0;
+END_TYPE;
+
+TYPE positive_plane_angle_measure = plane_angle_measure;
+WHERE
+	WR1 : SELF > 0.0;
+END_TYPE;
+
+TYPE positive_ratio_measure = ratio_measure;
+WHERE
+	WR1 : SELF > 0.0;
+END_TYPE;
+
+TYPE power_measure = REAL;
+END_TYPE;
+
+TYPE preferred_surface_curve_representation = ENUMERATION OF (
+	curve_3d,
+	pcurve_s1,
+	pcurve_s2 );
+END_TYPE;
+
+TYPE presentable_text = STRING;
+WHERE
+	WR1 : control_characters_free(SELF);
+END_TYPE;
+
+TYPE presentation_representation_select = SELECT (
+	presentation_representation,
+	presentation_set);
+END_TYPE;
+
+TYPE presentation_size_assignment_select = SELECT (
+	presentation_view,
+	presentation_area,
+	area_in_set);
+END_TYPE;
+
+TYPE presentation_style_select = SELECT (
+	point_style,
+	curve_style,
+	surface_style_usage,
+	symbol_style,
+	fill_area_style,
+	text_style,
+	null_style);
+END_TYPE;
+
+TYPE presented_item_select = SELECT (
+	action,
+	action_method,
+	action_relationship,
+	product_concept,
+	product_concept_feature,
+	product_concept_feature_category,
+	product_definition,
+	product_definition_formation,
+	product_definition_relationship);
+END_TYPE;
+
+TYPE pressure_measure = REAL;
+END_TYPE;
+
+TYPE product_definition_or_assembly_relationship = SELECT (
+	assembly_component_usage,
+	product_definition);
+END_TYPE;
+
+TYPE product_definition_or_breakdown_element_usage = SELECT (
+	product_definition,
+	product_definition_usage);
+END_TYPE;
+
+TYPE product_definition_or_product_definition_relationship = SELECT (
+	product_definition,
+	product_definition_usage);
+END_TYPE;
+
+TYPE product_or_formation_or_definition = SELECT (
+	product,
+	product_definition_formation,
+	product_definition);
+END_TYPE;
+
+TYPE project_item = SELECT (
+	executed_action,
+	product_concept);
+END_TYPE;
+
+TYPE radioactivity_measure = REAL;
+END_TYPE;
+
+TYPE ratio_measure = REAL;
+END_TYPE;
+
+TYPE rendering_properties_select = SELECT (
+	surface_style_reflectance_ambient,
+	surface_style_transparent);
+END_TYPE;
+
+TYPE represented_definition = SELECT (
+	general_property,
+	property_definition,
+	property_definition_relationship,
+	shape_aspect,
+	shape_aspect_relationship);
+END_TYPE;
+
+TYPE requirement_assigned_item = SELECT (
+	configuration_item,
+	descriptive_representation_item,
+	product,
+	product_class,
+	product_definition,
+	product_definition_formation,
+	product_definition_relationship,
+	representation,
+	shape_aspect);
+END_TYPE;
+
+TYPE requirement_satisfaction_item = SELECT (
+	requirement_assigned_item);
+END_TYPE;
+
+TYPE requirement_source_item = SELECT (
+	characterized_object,
+	group,
+	group_relationship,
+	product,
+	product_definition,
+	product_definition_formation,
+	product_definition_relationship,
+	shape_aspect);
+END_TYPE;
+
+TYPE resistance_measure = REAL;
+END_TYPE;
+
+TYPE reversible_topology = SELECT (
+	reversible_topology_item,
+	list_of_reversible_topology_item,
+	set_of_reversible_topology_item);
+END_TYPE;
+
+TYPE reversible_topology_item = SELECT (
+	edge,
+	path,
+	face,
+	face_bound,
+	closed_shell,
+	open_shell);
+END_TYPE;
+
+TYPE role_select = SELECT (
+	action_assignment,
+	action_request_assignment,
+	approval_assignment,
+	approval_date_time,
+	certification_assignment,
+	contract_assignment,
+	document_reference,
+	effectivity_assignment,
+	group_assignment,
+	name_assignment,
+	security_classification_assignment);
+END_TYPE;
+
+TYPE rule_superseded_item = SELECT (
+	product_definition_formation);
+END_TYPE;
+
+TYPE second_in_minute = REAL;
+WHERE
+	WR1 : { 0 <= SELF <= 60.0 };
+END_TYPE;
+
+TYPE security_classification_item = SELECT (
+	assembly_component_usage,
+	document,
+	document_file,
+	make_from_usage_option,
+	product,
+	product_definition,
+	product_definition_formation,
+	product_definition_usage);
+END_TYPE;
+
+TYPE set_of_reversible_topology_item = SET [0:?] OF reversible_topology_item;
+END_TYPE;
+
+TYPE set_representation_item = SET [1:?] OF representation_item;
+END_TYPE;
+
+TYPE shading_curve_method = ENUMERATION OF (
+	constant_colour,
+	linear_colour );
+END_TYPE;
+
+TYPE shading_surface_method = ENUMERATION OF (
+	constant_shading,
+	colour_shading,
+	dot_shading,
+	normal_shading );
+END_TYPE;
+
+TYPE shape_definition = SELECT (
+	product_definition_shape,
+	shape_aspect,
+	shape_aspect_relationship);
+END_TYPE;
+
+TYPE shell = SELECT (
+	vertex_shell,
+	wire_shell,
+	open_shell,
+	closed_shell);
+END_TYPE;
+
+TYPE si_prefix = ENUMERATION OF (
+	exa,
+	peta,
+	tera,
+	giga,
+	mega,
+	kilo,
+	hecto,
+	deca,
+	deci,
+	centi,
+	milli,
+	micro,
+	nano,
+	pico,
+	femto,
+	atto );
+END_TYPE;
+
+TYPE si_unit_name = ENUMERATION OF (
+	metre,
+	gram,
+	second,
+	ampere,
+	kelvin,
+	mole,
+	candela,
+	radian,
+	steradian,
+	hertz,
+	newton,
+	pascal,
+	joule,
+	watt,
+	coulomb,
+	volt,
+	farad,
+	ohm,
+	siemens,
+	weber,
+	tesla,
+	henry,
+	degree_Celsius,
+	lumen,
+	lux,
+	becquerel,
+	gray,
+	sievert );
+END_TYPE;
+
+TYPE size_select = SELECT (
+	positive_length_measure,
+	measure_with_unit,
+	descriptive_measure);
+END_TYPE;
+
+TYPE sketch_basis_select = SELECT (
+	curve_bounded_surface,
+	face_surface);
+END_TYPE;
+
+TYPE solid_angle_measure = REAL;
+END_TYPE;
+
+TYPE source = ENUMERATION OF (
+	made,
+	bought,
+	not_known );
+END_TYPE;
+
+TYPE source_item = SELECT (
+	identifier,
+	message);
+END_TYPE;
+
+TYPE start_request_item = SELECT (
+	product_definition_formation);
+END_TYPE;
+
+TYPE string_representation_item_select = SELECT (
+	descriptive_representation_item,
+	included_text_block,
+	structured_text_composition);
+END_TYPE;
+
+TYPE style_context_select = SELECT (
+	group,
+	presentation_layer_assignment,
+	presentation_set,
+	representation,
+	representation_item,
+	representation_relationship);
+END_TYPE;
+
+TYPE surface_side = ENUMERATION OF (
+	positive,
+	negative,
+	both );
+END_TYPE;
+
+TYPE surface_side_style_select = SELECT (
+	surface_side_style,
+	pre_defined_surface_side_style);
+END_TYPE;
+
+TYPE surface_style_element_select = SELECT (
+	surface_style_fill_area,
+	surface_style_boundary,
+	surface_style_silhouette,
+	surface_style_segmentation_curve,
+	surface_style_control_grid,
+	surface_style_parameter_line,
+	surface_style_rendering);
+END_TYPE;
+
+TYPE symbol_style_select = SELECT (
+	symbol_colour);
+END_TYPE;
+
+TYPE text = STRING;
+END_TYPE;
+
+TYPE text_alignment = label;
+END_TYPE;
+
+TYPE text_delineation = label;
+END_TYPE;
+
+TYPE text_or_character = SELECT (
+	annotation_text,
+	annotation_text_character,
+	composite_text,
+	text_literal);
+END_TYPE;
+
+TYPE text_path = ENUMERATION OF (
+	left,
+	right,
+	up,
+	down );
+END_TYPE;
+
+TYPE text_string_representation_item = SELECT (
+	text_literal,
+	annotation_text,
+	annotation_text_character,
+	composite_text,
+	axis2_placement);
+END_TYPE;
+
+TYPE thermodynamic_temperature_measure = REAL;
+END_TYPE;
+
+TYPE time_interval_item = SELECT (
+	action,
+	time_interval_based_effectivity);
+END_TYPE;
+
+TYPE time_measure = REAL;
+END_TYPE;
+
+TYPE tolerance_method_definition = SELECT (
+	tolerance_value,
+	limits_and_fits);
+END_TYPE;
+
+TYPE transformation = SELECT (
+	item_defined_transformation,
+	functionally_defined_transformation);
+END_TYPE;
+
+TYPE transition_code = ENUMERATION OF (
+	discontinuous,
+	continuous,
+	cont_same_gradient,
+	cont_same_gradient_same_curvature );
+END_TYPE;
+
+TYPE trim_condition_select = SELECT (
+	length_measure,
+	plane_angle_measure,
+	generalized_surface_select,
+	solid_model);
+END_TYPE;
+
+TYPE trim_intent = ENUMERATION OF (
+	blind,
+	offset,
+	through_all,
+	unspecified,
+	up_to_next );
+END_TYPE;
+
+TYPE trimming_preference = ENUMERATION OF (
+	cartesian,
+	parameter,
+	unspecified );
+END_TYPE;
+
+TYPE trimming_select = SELECT (
+	cartesian_point,
+	parameter_value);
+END_TYPE;
+
+TYPE u_direction_count = INTEGER;
+WHERE
+	WR1 : SELF > 1;
+END_TYPE;
+
+TYPE unit = SELECT (
+	derived_unit,
+	named_unit);
+END_TYPE;
+
+TYPE v_direction_count = INTEGER;
+WHERE
+	WR1 : SELF > 1;
+END_TYPE;
+
+TYPE value_qualifier = SELECT (
+	precision_qualifier,
+	type_qualifier,
+	uncertainty_qualifier);
+END_TYPE;
+
+TYPE vector_or_direction = SELECT (
+	vector,
+	direction);
+END_TYPE;
+
+TYPE velocity_measure = REAL;
+END_TYPE;
+
+TYPE volume_measure = REAL;
+END_TYPE;
+
+TYPE week_in_year_number = INTEGER;
+WHERE
+	WR1 : { 1 <= SELF <= 53 };
+END_TYPE;
+
+TYPE work_item = SELECT (
+	product_definition_formation);
+END_TYPE;
+
+TYPE year_number = INTEGER;
+END_TYPE;
+
+ENTITY absorbed_dose_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ABSORBED_DOSE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY absorbed_dose_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.gray);
+END_ENTITY;
+
+
+ENTITY abstract_variable
+	SUBTYPE OF (property_definition, property_definition_representation, representation, representation_item);
+END_ENTITY;
+
+
+ENTITY acceleration_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ACCELERATION_UNIT' IN TYPEOF (SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY acceleration_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = 
+       dimensional_exponents ( 1.0, 0.0, -2.0, 0.0, 0.0, 0.0, 0.0 );
+END_ENTITY;
+
+
+ENTITY action;
+	name : label;
+	description : OPTIONAL text;
+	chosen_method : action_method;
+DERIVE
+	id : identifier := get_id_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY action_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_action : action;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY action_directive;
+	name : label;
+	description : OPTIONAL text;
+	analysis : text;
+	comment : text;
+	requests : SET [1:?] OF versioned_action_request;
+END_ENTITY;
+
+
+ENTITY action_method;
+	name : label;
+	description : OPTIONAL text;
+	consequence : text;
+	purpose : text;
+END_ENTITY;
+
+
+ENTITY action_method_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_action_method : action_method;
+	role : action_method_role;
+END_ENTITY;
+
+
+ENTITY action_method_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_method : action_method;
+	related_method : action_method;
+END_ENTITY;
+
+
+ENTITY action_method_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY action_property;
+	name : label;
+	description : text;
+	definition : characterized_action_definition;
+END_ENTITY;
+
+
+ENTITY action_property_representation;
+	name : label;
+	description : text;
+	property : action_property;
+	representation : representation;
+END_ENTITY;
+
+
+ENTITY action_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_action : action;
+	related_action : action;
+END_ENTITY;
+
+
+ENTITY action_request_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_action_request : versioned_action_request;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY action_request_solution;
+	method : action_method;
+	request : versioned_action_request;
+DERIVE
+	description : text := get_description_value(SELF);
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY action_request_status;
+	status : label;
+	assigned_request : versioned_action_request;
+END_ENTITY;
+
+
+ENTITY action_status;
+	status : label;
+	assigned_action : executed_action;
+END_ENTITY;
+
+
+ENTITY address;
+	internal_location : OPTIONAL label;
+	street_number : OPTIONAL label;
+	street : OPTIONAL label;
+	postal_box : OPTIONAL label;
+	town : OPTIONAL label;
+	region : OPTIONAL label;
+	postal_code : OPTIONAL label;
+	country : OPTIONAL label;
+	facsimile_number : OPTIONAL label;
+	telephone_number : OPTIONAL label;
+	electronic_mail_address : OPTIONAL label;
+	telex_number : OPTIONAL label;
+DERIVE
+	name : label := get_name_value(SELF);
+	url : identifier := get_id_value(SELF);
+WHERE
+	WR1 : EXISTS(internal_location) OR EXISTS(street_number) OR EXISTS(street) OR EXISTS(postal_box) OR EXISTS(town) OR EXISTS(region) OR EXISTS(postal_code) OR EXISTS(country) OR EXISTS(facsimile_number) OR EXISTS(telephone_number) OR EXISTS(electronic_mail_address) OR EXISTS(telex_number);
+END_ENTITY;
+
+
+ENTITY advanced_brep_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF ( 
+QUERY ( it <* SELF.items| NOT ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACETED_BREP', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D' ] * TYPEOF (it)) = 1) )) = 0;
+	WR2 : SIZEOF ( 
+QUERY ( it <* SELF.items| ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' ] * TYPEOF (it)) = 1) )) > 0;
+	WR3 : SIZEOF ( 
+QUERY ( msb <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( csh <* msb_shells(msb)| NOT ( SIZEOF ( 
+QUERY ( fcs <* csh\connected_face_set.cfs_faces| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fcs)) )) = 0) )) = 0) )) = 0;
+	WR4 : SIZEOF ( 
+QUERY ( msb <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF (it)) )| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_CLOSED_SHELL' IN TYPEOF (msb\manifold_solid_brep.outer)) )) = 0;
+	WR5 : SIZEOF ( 
+QUERY ( brv <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BREP_WITH_VOIDS' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( csh <* brv\brep_with_voids.voids| csh\oriented_closed_shell.orientation )) = 0) )) = 0;
+	WR6 : SIZEOF ( 
+QUERY ( mi <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_BREP_SHAPE_REPRESENTATION' IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation)) )) = 0;
+END_ENTITY;
+
+
+ENTITY advanced_face
+	SUBTYPE OF (face_surface);
+WHERE
+	WR1 : SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELEMENTARY_SURFACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_SURFACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_SURFACE' ] * TYPEOF (face_geometry)) = 1;
+	WR2 : SIZEOF ( 
+QUERY ( elp_fbnds <* 
+QUERY ( bnds <* bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) )| NOT ( SIZEOF ( 
+QUERY ( oe <* elp_fbnds.bound\path.edge_list| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN TYPEOF (oe\oriented_edge.edge_element)) )) = 0) )) = 0;
+	WR3 : SIZEOF ( 
+QUERY ( elp_fbnds <* 
+QUERY ( bnds <* bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) )| NOT ( SIZEOF ( 
+QUERY ( oe <* elp_fbnds.bound\path.edge_list| NOT ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' ] * TYPEOF (oe.edge_element\edge_curve.edge_geometry)) = 1) )) = 0) )) = 0;
+	WR4 : SIZEOF ( 
+QUERY ( elp_fbnds <* 
+QUERY ( bnds <* bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) )| NOT ( SIZEOF ( 
+QUERY ( oe <* elp_fbnds.bound\path.edge_list| NOT ((('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (oe\edge.edge_start)) AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF (oe\edge.edge_start\vertex_point.vertex_geometry))) AND (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (oe\edge.edge_end)) AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF (oe\edge.edge_end\vertex_point.vertex_geometry)))) )) = 0) )) = 0;
+	WR5 : SIZEOF ( 
+QUERY ( elp_fbnds <* 
+QUERY ( bnds <* bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) )| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_PATH' IN TYPEOF (elp_fbnds.bound)) )) = 0;
+	WR6 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_SURFACE' IN TYPEOF (face_geometry)) OR ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' ] * TYPEOF (face_geometry\swept_surface.swept_curve)) = 1);
+	WR7 : SIZEOF ( 
+QUERY ( vlp_fbnds <* 
+QUERY ( bnds <* bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF (bnds.bound)) )| NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (vlp_fbnds\face_bound.bound\vertex_loop.loop_vertex)) AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF (vlp_fbnds\face_bound.bound\vertex_loop.loop_vertex\vertex_point.vertex_geometry))) )) = 0;
+	WR8 : SIZEOF ( 
+QUERY ( bnd <* bounds| NOT ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' ] * TYPEOF (bnd.bound)) = 1) )) = 0;
+	WR9 : SIZEOF ( 
+QUERY ( elp_fbnds <* 
+QUERY ( bnds <* bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) )| NOT ( SIZEOF ( 
+QUERY ( oe <* elp_fbnds.bound\path.edge_list| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN TYPEOF (oe\oriented_edge.edge_element\edge_curve.edge_geometry)) AND NOT ( SIZEOF ( 
+QUERY ( sc_ag <* oe.edge_element\edge_curve.edge_geometry\surface_curve.associated_geometry| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF (sc_ag)) )) = 0) )) = 0) )) = 0;
+	WR10 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_SURFACE' IN TYPEOF (face_geometry)) OR (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF (face_geometry\swept_surface.swept_curve)) OR ( SIZEOF (face_geometry\swept_surface.swept_curve\polyline.points) >= 3))) AND ( SIZEOF ( 
+QUERY ( elp_fbnds <* 
+QUERY ( bnds <* bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) )| NOT ( SIZEOF ( 
+QUERY ( oe <* elp_fbnds.bound\path.edge_list| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF (oe\oriented_edge.edge_element\edge_curve.edge_geometry)) AND NOT ( SIZEOF (oe\oriented_edge.edge_element\edge_curve.edge_geometry\polyline.points) >= 3) )) = 0) )) = 0);
+END_ENTITY;
+
+
+ENTITY alternate_product_relationship;
+	name : label;
+	definition : OPTIONAL text;
+	alternate : product;
+	base : product;
+	basis : text;
+UNIQUE
+	UR1 : alternate, base;
+WHERE
+	WR1 : alternate :<>: base;
+END_ENTITY;
+
+
+ENTITY amount_of_substance_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AMOUNT_OF_SUBSTANCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY amount_of_substance_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 1.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY angle_direction_reference
+	SUBTYPE OF (representation_item_relationship, geometric_representation_item);
+	SELF\representation_item_relationship.related_representation_item : angle_direction_reference_select;
+	SELF\representation_item_relationship.relating_representation_item : orientation_basis_select;
+WHERE
+	WR1 : ((('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_PATH' IN TYPEOF(related_representation_item)) AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MIN_AND_MAJOR_PLY_ORIENTATION_BASIS' IN TYPEOF(relating_representation_item))) 
+        OR
+		(NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_PATH' IN TYPEOF(related_representation_item)) AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D' IN TYPEOF(relating_representation_item))));
+END_ENTITY;
+
+
+ENTITY angular_dimension
+	SUBTYPE OF (dimension_curve_directed_callout);
+END_ENTITY;
+
+
+ENTITY angular_location
+	SUBTYPE OF (dimensional_location);
+	angle_selection : angle_relator;
+END_ENTITY;
+
+
+ENTITY angular_size
+	SUBTYPE OF (dimensional_size);
+	angle_selection : angle_relator;
+END_ENTITY;
+
+
+ENTITY angularity_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) < 3;
+END_ENTITY;
+
+
+ENTITY annotation_curve_occurrence
+	SUBTYPE OF (annotation_occurrence);
+	SELF\styled_item.item : curve;
+END_ENTITY;
+
+
+ENTITY annotation_fill_area
+	SUBTYPE OF (geometric_representation_item);
+	boundaries : SET [1:?] OF curve;
+WHERE
+	WR1 : (SELF\geometric_representation_item.dim = 3) OR (SIZEOF (QUERY (curve <* SELF.boundaries |
+          NOT (
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCLE' IN TYPEOF (curve)) OR 
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELLIPSE' IN TYPEOF (curve)) OR 
+              ( ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' IN TYPEOF (curve)) 
+                   AND (curve\b_spline_curve.closed_curve = TRUE) ) OR 
+              ( ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE' IN TYPEOF (curve)) 
+                   AND (curve\composite_curve.closed_curve = TRUE) ) OR 
+              ( ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF (curve)) 
+                   AND (curve\polyline.points[LOINDEX(curve\polyline.points)] = 
+                        curve\polyline.points[HIINDEX(curve\polyline.points)]) )
+              ) )) = 0);
+END_ENTITY;
+
+
+ENTITY annotation_fill_area_occurrence
+	SUBTYPE OF (annotation_occurrence);
+	fill_style_target : point;
+	SELF\styled_item.item : annotation_fill_area;
+END_ENTITY;
+
+
+ENTITY annotation_occurrence
+	SUPERTYPE OF (ONEOF (annotation_curve_occurrence, annotation_fill_area_occurrence, annotation_text_occurrence, annotation_symbol_occurrence))
+	SUBTYPE OF (styled_item);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_ITEM' IN
+             TYPEOF (SELF);
+	WR2 : SIZEOF (QUERY (reps <* using_representations(SELF) | 
+        NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_REPRESENTATION_SELECT' IN TYPEOF(reps)))) = 0;
+END_ENTITY;
+
+
+ENTITY annotation_occurrence_associativity
+	SUBTYPE OF (annotation_occurrence_relationship);
+WHERE
+	WR1 : SIZEOF (TYPEOF (SELF.related_annotation_occurrence) *
+          ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_FILL_AREA_OCCURRENCE',
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_CURVE',
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_CURVE']) = 1;
+END_ENTITY;
+
+
+ENTITY annotation_occurrence_relationship;
+	name : label;
+	description : text;
+	relating_annotation_occurrence : annotation_occurrence;
+	related_annotation_occurrence : annotation_occurrence;
+END_ENTITY;
+
+
+ENTITY annotation_plane
+	SUBTYPE OF (annotation_occurrence, geometric_representation_item);
+	elements : OPTIONAL SET [1:?] OF annotation_plane_element;
+	SELF\styled_item.item : plane_or_planar_box;
+WHERE
+	WR1 : SELF\geometric_representation_item.dim = 3;
+	WR2 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PLANAR_BOX' IN TYPEOF(SELF\styled_item.item)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'AXIS2_PLACEMENT_3D' IN TYPEOF(SELF\styled_item.item\planar_box.placement));
+	WR3 : (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PLANAR_BOX' IN TYPEOF(SELF\styled_item.item)) AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'CURVE_STYLE' IN TYPEOF(SELF\styled_item.styles[1]\presentation_style_assignment.styles[1]))) OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PLANE' IN TYPEOF(SELF\styled_item.item)) AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'FILL_AREA_STYLE' IN TYPEOF(SELF\styled_item.styles[1]\presentation_style_assignment.styles[1])));
+	WR4 : (SIZEOF(SELF\styled_item.styles) = 1) AND
+        (SIZEOF(SELF\styled_item.styles[1]\presentation_style_assignment.styles) = 1);
+END_ENTITY;
+
+
+ENTITY annotation_subfigure_occurrence
+	SUBTYPE OF (annotation_symbol_occurrence);
+WHERE
+	WR1 : SIZEOF (QUERY (sty <* SELF.styles |
+         NOT (SIZEOF (sty.styles) = 1)
+       )) = 0;
+	WR2 : SIZEOF (QUERY (sty <* SELF.styles |
+         NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NULL_STYLE'
+               IN TYPEOF (sty.styles[1]))       ))=0;
+	WR3 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL'
+           IN TYPEOF (SELF.item));
+	WR4 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_SUBFIGURE_REPRESENTATION'
+           IN TYPEOF
+           (SELF.item\mapped_item.mapping_source.mapped_representation));
+END_ENTITY;
+
+
+ENTITY annotation_symbol
+	SUBTYPE OF (mapped_item);
+	SELF\mapped_item.mapping_source : symbol_representation_map;
+	SELF\mapped_item.mapping_target : symbol_target;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_ITEM' IN
+          TYPEOF (SELF);
+END_ENTITY;
+
+
+ENTITY annotation_symbol_occurrence
+	SUBTYPE OF (annotation_occurrence);
+	SELF\styled_item.item : annotation_symbol_occurrence_item;
+END_ENTITY;
+
+
+ENTITY annotation_text
+	SUBTYPE OF (mapped_item);
+	SELF\mapped_item.mapping_target : axis2_placement;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_STRING_REPRESENTATION' IN
+        TYPEOF( SELF\mapped_item.mapping_source.mapped_representation);
+	WR2 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_ITEM' IN
+        TYPEOF( SELF);
+END_ENTITY;
+
+
+ENTITY annotation_text_character
+	SUBTYPE OF (mapped_item);
+	alignment : text_alignment;
+	SELF\mapped_item.mapping_target : axis2_placement;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CHARACTER_GLYPH_SYMBOL' IN
+         TYPEOF (SELF\mapped_item.mapping_source.mapped_representation);
+	WR2 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_ITEM' IN
+         TYPEOF (SELF);
+END_ENTITY;
+
+
+ENTITY annotation_text_occurrence
+	SUBTYPE OF (annotation_occurrence);
+	SELF\styled_item.item : annotation_text_occurrence_item;
+END_ENTITY;
+
+
+ENTITY apex
+	SUBTYPE OF (derived_shape_aspect);
+END_ENTITY;
+
+
+ENTITY application_context;
+	application : label;
+DERIVE
+	description : text := get_description_value(SELF);
+	id : identifier := get_id_value(SELF);
+INVERSE
+	context_elements: SET [1:?] OF application_context_element FOR frame_of_reference;
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY application_context_element
+	SUPERTYPE OF (ONEOF (product_concept_context, product_context, product_definition_context));
+	name : label;
+	frame_of_reference : application_context;
+END_ENTITY;
+
+
+ENTITY application_protocol_definition;
+	status : label;
+	application_interpreted_model_schema_name : label;
+	application_protocol_year : year_number;
+	application : application_context;
+END_ENTITY;
+
+
+ENTITY applied_action_assignment
+	SUBTYPE OF (action_assignment);
+	items : SET [1:?] OF action_items;
+END_ENTITY;
+
+
+ENTITY applied_action_method_assignment
+	SUBTYPE OF (action_method_assignment);
+	items : SET [1:?] OF action_method_items;
+END_ENTITY;
+
+
+ENTITY applied_action_request_assignment
+	SUBTYPE OF (action_request_assignment);
+	items : SET [1:?] OF action_request_item;
+END_ENTITY;
+
+
+ENTITY applied_approval_assignment
+	SUBTYPE OF (approval_assignment);
+	items : SET [1:?] OF approval_item;
+END_ENTITY;
+
+
+ENTITY applied_attribute_classification_assignment
+	SUBTYPE OF (attribute_classification_assignment);
+	items : SET [1:?] OF attribute_classification_item;
+	SELF\attribute_classification_assignment.assigned_class : class;
+END_ENTITY;
+
+
+ENTITY applied_certification_assignment
+	SUBTYPE OF (certification_assignment);
+	items : SET [1:?] OF certification_item;
+END_ENTITY;
+
+
+ENTITY applied_classification_assignment
+	SUBTYPE OF (classification_assignment);
+	items : SET [1:?] OF classification_item;
+END_ENTITY;
+
+
+ENTITY applied_contract_assignment
+	SUBTYPE OF (contract_assignment);
+	items : SET [1:?] OF contract_item;
+END_ENTITY;
+
+
+ENTITY applied_date_and_time_assignment
+	SUBTYPE OF (date_and_time_assignment);
+	items : SET [1:?] OF date_and_time_item;
+END_ENTITY;
+
+
+ENTITY applied_date_assignment
+	SUBTYPE OF (date_assignment);
+	items : SET [1:?] OF date_item;
+END_ENTITY;
+
+
+ENTITY applied_document_reference
+	SUBTYPE OF (document_reference);
+	items : SET [1:?] OF document_reference_item;
+END_ENTITY;
+
+
+ENTITY applied_document_usage_constraint_assignment
+	SUBTYPE OF (document_usage_constraint_assignment);
+	items : SET [1:?] OF document_reference_item;
+END_ENTITY;
+
+
+ENTITY applied_effectivity_assignment
+	SUBTYPE OF (effectivity_assignment);
+	items : SET [1:?] OF effectivity_item;
+END_ENTITY;
+
+
+ENTITY applied_event_occurrence_assignment
+	SUBTYPE OF (event_occurrence_assignment);
+	items : SET [1:?] OF event_occurrence_item;
+END_ENTITY;
+
+
+ENTITY applied_external_identification_assignment
+	SUBTYPE OF (external_identification_assignment);
+	items : SET [1:?] OF external_identification_item;
+END_ENTITY;
+
+
+ENTITY applied_group_assignment
+	SUBTYPE OF (group_assignment);
+	items : SET [1:?] OF groupable_item;
+END_ENTITY;
+
+
+ENTITY applied_identification_assignment
+	SUBTYPE OF (identification_assignment);
+	items : SET [1:?] OF identification_item;
+END_ENTITY;
+
+
+ENTITY applied_name_assignment
+	SUBTYPE OF (name_assignment);
+	item : name_item;
+END_ENTITY;
+
+
+ENTITY applied_organization_assignment
+	SUBTYPE OF (organization_assignment);
+	items : SET [1:?] OF organization_item;
+END_ENTITY;
+
+
+ENTITY applied_organizational_project_assignment
+	SUBTYPE OF (organizational_project_assignment);
+	items : SET [1:?] OF project_item;
+END_ENTITY;
+
+
+ENTITY applied_person_and_organization_assignment
+	SUBTYPE OF (person_and_organization_assignment);
+	items : SET [1:?] OF person_and_organization_item;
+END_ENTITY;
+
+
+ENTITY applied_presented_item
+	SUBTYPE OF (presented_item);
+	items : SET [1:?] OF presented_item_select;
+END_ENTITY;
+
+
+ENTITY applied_security_classification_assignment
+	SUBTYPE OF (security_classification_assignment);
+	items : SET [1:?] OF security_classification_item;
+END_ENTITY;
+
+
+ENTITY applied_time_interval_assignment
+	SUBTYPE OF (time_interval_assignment);
+	items : SET [0:?] OF time_interval_item;
+END_ENTITY;
+
+
+ENTITY applied_usage_right
+	SUBTYPE OF (applied_action_assignment);
+	SELF\applied_action_assignment.items : SET [1:?] OF ir_usage_item;
+END_ENTITY;
+
+
+ENTITY approval;
+	status : approval_status;
+	level : label;
+END_ENTITY;
+
+
+ENTITY approval_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_approval : approval;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY approval_date_time;
+	date_time : date_time_select;
+	dated_approval : approval;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY approval_person_organization;
+	person_organization : person_organization_select;
+	authorized_approval : approval;
+	role : approval_role;
+END_ENTITY;
+
+
+ENTITY approval_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_approval : approval;
+	related_approval : approval;
+END_ENTITY;
+
+
+ENTITY approval_role;
+	role : label;
+DERIVE
+	description : text := get_description_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY approval_status;
+	name : label;
+END_ENTITY;
+
+
+ENTITY area_in_set;
+	area : presentation_area;
+	in_set : presentation_set;
+END_ENTITY;
+
+
+ENTITY area_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AREA_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY area_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = 
+      dimensional_exponents ( 2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 );
+END_ENTITY;
+
+
+ENTITY assembly_component_usage
+	SUPERTYPE OF (ONEOF (next_assembly_usage_occurrence, specified_higher_usage_occurrence, promissory_usage_occurrence))
+	SUBTYPE OF (product_definition_usage);
+	reference_designator : OPTIONAL identifier;
+END_ENTITY;
+
+
+ENTITY assembly_component_usage_substitute;
+	name : label;
+	definition : OPTIONAL text;
+	base : assembly_component_usage;
+	substitute : assembly_component_usage;
+UNIQUE
+	UR1 : base, substitute;
+WHERE
+	WR1 : base.relating_product_definition :=:
+       substitute.relating_product_definition;
+	WR2 : base :<>: substitute;
+END_ENTITY;
+
+
+ENTITY assigned_requirement
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF product_definition;
+	SELF\group_assignment.assigned_group : requirement_assignment;
+END_ENTITY;
+
+
+ENTITY atomic_formula
+	SUBTYPE OF (compound_representation_item);
+END_ENTITY;
+
+
+ENTITY attribute_assertion
+	SUBTYPE OF (fact_type, property_definition_representation, representation);
+END_ENTITY;
+
+
+ENTITY attribute_classification_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_class : group;
+	attribute_name : label;
+	role : classification_role;
+END_ENTITY;
+
+
+ENTITY attribute_language_assignment
+	SUBTYPE OF (attribute_classification_assignment);
+	items : SET [1:?] OF attribute_language_item;
+	SELF\attribute_classification_assignment.assigned_class : language;
+WHERE
+	WR1 : SELF\attribute_classification_assignment.role.name IN ['primary', 'translated'];
+	WR2 : SELF\attribute_classification_assignment.attribute_name<> '';
+END_ENTITY;
+
+
+ENTITY attribute_value_assignment
+	ABSTRACT SUPERTYPE;
+	attribute_name : label;
+	attribute_value : attribute_type;
+	role : attribute_value_role;
+END_ENTITY;
+
+
+ENTITY attribute_value_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY auxiliary_geometric_representation_item
+	SUBTYPE OF (geometric_representation_item, variational_representation_item);
+END_ENTITY;
+
+
+ENTITY axis1_placement
+	SUBTYPE OF (placement);
+	axis : OPTIONAL direction;
+DERIVE
+	z : direction := NVL(normalise(axis), dummy_gri ||
+                                 direction([0.0,0.0,1.0]));
+WHERE
+	WR1 : SELF\geometric_representation_item.dim  = 3;
+END_ENTITY;
+
+
+ENTITY axis2_placement_2d
+	SUBTYPE OF (placement);
+	ref_direction : OPTIONAL direction;
+DERIVE
+	p : LIST [2:2] OF direction := build_2axes(ref_direction);
+WHERE
+	WR1 : SELF\geometric_representation_item.dim = 2;
+END_ENTITY;
+
+
+ENTITY axis2_placement_3d
+	SUBTYPE OF (placement);
+	axis : OPTIONAL direction;
+	ref_direction : OPTIONAL direction;
+DERIVE
+	p : LIST [3:3] OF direction := build_axes(axis,ref_direction);
+WHERE
+	WR1 : SELF\placement.location.dim = 3;
+	WR2 : (NOT (EXISTS (axis))) OR (axis.dim = 3);
+	WR3 : (NOT (EXISTS (ref_direction))) OR (ref_direction.dim = 3);
+	WR4 : (NOT (EXISTS (axis))) OR (NOT (EXISTS (ref_direction))) OR
+          (cross_product(axis,ref_direction).magnitude > 0.0);
+END_ENTITY;
+
+
+ENTITY b_spline_curve
+	SUPERTYPE OF ((ONEOF (uniform_curve, b_spline_curve_with_knots, quasi_uniform_curve, bezier_curve) ANDOR rational_b_spline_curve))
+	SUBTYPE OF (bounded_curve);
+	degree : INTEGER;
+	control_points_list : LIST [2:?] OF cartesian_point;
+	curve_form : b_spline_curve_form;
+	closed_curve : LOGICAL;
+	self_intersect : LOGICAL;
+DERIVE
+	control_points : ARRAY [0:upper_index_on_control_points] OF cartesian_point := list_to_array(control_points_list,0,
+                                             upper_index_on_control_points);
+	upper_index_on_control_points : INTEGER := (SIZEOF(control_points_list) - 1);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.UNIFORM_CURVE' IN TYPEOF(self)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.QUASI_UNIFORM_CURVE' IN TYPEOF(self)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BEZIER_CURVE' IN TYPEOF(self)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE_WITH_KNOTS' IN TYPEOF(self));
+END_ENTITY;
+
+
+ENTITY b_spline_curve_with_knots
+	SUBTYPE OF (b_spline_curve);
+	knot_multiplicities : LIST [2:?] OF INTEGER;
+	knots : LIST [2:?] OF parameter_value;
+	knot_spec : knot_type;
+DERIVE
+	upper_index_on_knots : INTEGER := SIZEOF(knots);
+WHERE
+	WR1 : constraints_param_b_spline(degree, upper_index_on_knots,
+                               upper_index_on_control_points,
+                               knot_multiplicities, knots);
+	WR2 : SIZEOF(knot_multiplicities) = upper_index_on_knots;
+END_ENTITY;
+
+
+ENTITY b_spline_surface
+	SUPERTYPE OF ((ONEOF (b_spline_surface_with_knots, uniform_surface, quasi_uniform_surface, bezier_surface) ANDOR rational_b_spline_surface))
+	SUBTYPE OF (bounded_surface);
+	u_degree : INTEGER;
+	v_degree : INTEGER;
+	control_points_list : LIST [2:?] OF LIST [2:?] OF cartesian_point;
+	surface_form : b_spline_surface_form;
+	u_closed : LOGICAL;
+	v_closed : LOGICAL;
+	self_intersect : LOGICAL;
+DERIVE
+	control_points : ARRAY [0:u_upper] OF ARRAY [0:v_upper] OF cartesian_point := make_array_of_array(control_points_list,
+                                              0,u_upper,0,v_upper);
+	u_upper : INTEGER := SIZEOF(control_points_list) - 1;
+	v_upper : INTEGER := SIZEOF(control_points_list[1]) - 1;
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.UNIFORM_SURFACE' IN TYPEOF(SELF)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.QUASI_UNIFORM_SURFACE' IN TYPEOF(SELF)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BEZIER_SURFACE' IN TYPEOF(SELF)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_SURFACE_WITH_KNOTS' IN TYPEOF(SELF));
+END_ENTITY;
+
+
+ENTITY b_spline_surface_with_knots
+	SUBTYPE OF (b_spline_surface);
+	u_multiplicities : LIST [2:?] OF INTEGER;
+	v_multiplicities : LIST [2:?] OF INTEGER;
+	u_knots : LIST [2:?] OF parameter_value;
+	v_knots : LIST [2:?] OF parameter_value;
+	knot_spec : knot_type;
+DERIVE
+	knot_u_upper : INTEGER := SIZEOF(u_knots);
+	knot_v_upper : INTEGER := SIZEOF(v_knots);
+WHERE
+	WR1 : constraints_param_b_spline(SELF\b_spline_surface.u_degree,
+                   knot_u_upper, SELF\b_spline_surface.u_upper,
+                               u_multiplicities, u_knots);
+	WR2 : constraints_param_b_spline(SELF\b_spline_surface.v_degree,
+                   knot_v_upper, SELF\b_spline_surface.v_upper,
+                               v_multiplicities, v_knots);
+	WR3 : SIZEOF(u_multiplicities) = knot_u_upper;
+	WR4 : SIZEOF(v_multiplicities) = knot_v_upper;
+END_ENTITY;
+
+
+ENTITY back_chaining_rule
+	SUBTYPE OF (rule_definition);
+END_ENTITY;
+
+
+ENTITY back_chaining_rule_body
+	SUBTYPE OF (property_definition, property_definition_representation, representation);
+END_ENTITY;
+
+
+ENTITY background_colour
+	SUBTYPE OF (colour);
+	presentation : area_or_view;
+UNIQUE
+	UR1 : presentation;
+END_ENTITY;
+
+
+ENTITY beveled_sheet_representation
+	SUBTYPE OF (shape_representation);
+END_ENTITY;
+
+
+ENTITY bezier_curve
+	SUBTYPE OF (b_spline_curve);
+END_ENTITY;
+
+
+ENTITY bezier_surface
+	SUBTYPE OF (b_spline_surface);
+END_ENTITY;
+
+
+ENTITY binary_generic_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (generic_expression);
+	operands : LIST [2:2] OF generic_expression;
+END_ENTITY;
+
+
+ENTITY binary_numeric_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (numeric_expression, binary_generic_expression);
+	SELF\binary_generic_expression.operands : LIST [2:2] OF numeric_expression;
+END_ENTITY;
+
+
+ENTITY binary_representation_item
+	SUBTYPE OF (representation_item);
+	binary_value : BINARY;
+END_ENTITY;
+
+
+ENTITY block
+	SUBTYPE OF (geometric_representation_item);
+	position : axis2_placement_3d;
+	x : positive_length_measure;
+	y : positive_length_measure;
+	z : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY boolean_expression
+	ABSTRACT SUPERTYPE OF (ONEOF (simple_boolean_expression, multiple_arity_boolean_expression, comparison_expression, interval_expression))
+	SUBTYPE OF (expression);
+END_ENTITY;
+
+
+ENTITY boolean_literal
+	SUBTYPE OF (simple_boolean_expression, generic_literal);
+	the_value : BOOLEAN;
+END_ENTITY;
+
+
+ENTITY boolean_representation_item
+	SUBTYPE OF (representation_item, boolean_literal);
+END_ENTITY;
+
+
+ENTITY boolean_result
+	SUBTYPE OF (geometric_representation_item);
+	operator : boolean_operator;
+	first_operand : boolean_operand;
+	second_operand : boolean_operand;
+END_ENTITY;
+
+
+ENTITY boundary_curve
+	SUBTYPE OF (composite_curve_on_surface);
+WHERE
+	WR1 : SELF\composite_curve.closed_curve;
+END_ENTITY;
+
+
+ENTITY bounded_curve
+	SUPERTYPE OF (ONEOF (polyline, b_spline_curve, trimmed_curve, bounded_pcurve, bounded_surface_curve, composite_curve))
+	SUBTYPE OF (curve);
+END_ENTITY;
+
+
+ENTITY bounded_pcurve
+	SUBTYPE OF (pcurve, bounded_curve);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_CURVE' IN
+                   TYPEOF(SELF\pcurve.reference_to_curve.items[1]));
+END_ENTITY;
+
+
+ENTITY bounded_surface
+	SUPERTYPE OF (ONEOF (b_spline_surface, rectangular_trimmed_surface, curve_bounded_surface, rectangular_composite_surface))
+	SUBTYPE OF (surface);
+END_ENTITY;
+
+
+ENTITY bounded_surface_curve
+	SUBTYPE OF (surface_curve, bounded_curve);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_CURVE' IN
+             TYPEOF(SELF\surface_curve.curve_3d));
+END_ENTITY;
+
+
+ENTITY box_domain
+	SUBTYPE OF (founded_item);
+	corner : cartesian_point;
+	xlength : positive_length_measure;
+	ylength : positive_length_measure;
+	zlength : positive_length_measure;
+WHERE
+	WR1 : SIZEOF(QUERY(item <* USEDIN(SELF,'')|
+             NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOXED_HALF_SPACE'
+                    IN TYPEOF(item)))) = 0;
+END_ENTITY;
+
+
+ENTITY boxed_half_space
+	SUBTYPE OF (half_space_solid);
+	enclosure : box_domain;
+END_ENTITY;
+
+
+ENTITY breakdown_context
+	SUBTYPE OF (product_definition_relationship);
+END_ENTITY;
+
+
+ENTITY breakdown_element_group_assignment
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF product_definition_or_breakdown_element_usage;
+	SELF\group_assignment.assigned_group : product_definition_element_relationship;
+END_ENTITY;
+
+
+ENTITY breakdown_element_realization
+	SUBTYPE OF (characterized_object, product_definition_element_relationship);
+END_ENTITY;
+
+
+ENTITY breakdown_element_usage
+	SUBTYPE OF (product_definition_relationship);
+END_ENTITY;
+
+
+ENTITY breakdown_of
+	SUBTYPE OF (product_definition_relationship);
+END_ENTITY;
+
+
+ENTITY brep_with_voids
+	SUBTYPE OF (manifold_solid_brep);
+	voids : SET [1:?] OF oriented_closed_shell;
+END_ENTITY;
+
+
+ENTITY bytes_representation_item
+	SUBTYPE OF (binary_representation_item);
+DERIVE
+	no_of_bytes : INTEGER := BLENGTH(SELF\binary_representation_item.binary_value) DIV 8;
+WHERE
+	WR1 : BLENGTH(SELF\binary_representation_item.binary_value) MOD 8 = 0;
+END_ENTITY;
+
+
+ENTITY calendar_date
+	SUBTYPE OF (date);
+	day_component : day_in_month_number;
+	month_component : month_in_year_number;
+WHERE
+	WR1 : valid_calendar_date (SELF);
+END_ENTITY;
+
+
+ENTITY camera_image
+	SUBTYPE OF (mapped_item);
+	SELF\mapped_item.mapping_source : camera_usage;
+	SELF\mapped_item.mapping_target : planar_box;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_ITEM'
+        IN TYPEOF (SELF);
+END_ENTITY;
+
+
+ENTITY camera_image_3d_with_scale
+	SUBTYPE OF (camera_image);
+DERIVE
+	scale : positive_ratio_measure := ((SELF\mapped_item.mapping_target\
+           planar_extent.size_in_x) / (SELF\mapped_item.mapping_source.
+           mapping_origin\camera_model_d3.perspective_of_volume.view_window.
+           size_in_x));
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CAMERA_MODEL_D3'
+         IN TYPEOF (SELF\mapped_item.mapping_source.mapping_origin));
+	WR2 : aspect_ratio(SELF\mapped_item.mapping_target) =
+           aspect_ratio(SELF\mapped_item.mapping_source.mapping_origin\
+           camera_model_d3.perspective_of_volume.view_window);
+	WR3 : SELF\mapped_item.mapping_source.mapping_origin\camera_model_d3.
+           perspective_of_volume.front_plane_clipping
+           AND
+           SELF\mapped_item.mapping_source.mapping_origin\camera_model_d3.
+           perspective_of_volume.view_volume_sides_clipping;
+	WR4 : (SELF\mapped_item.mapping_target\planar_extent.size_in_x > 0)
+           AND
+           (SELF\mapped_item.mapping_target\planar_extent.size_in_y > 0);
+	WR5 : (SELF\mapped_item.mapping_source.mapping_origin\camera_model_d3.
+           perspective_of_volume.view_window.size_in_x > 0)
+           AND
+           (SELF\mapped_item.mapping_source.mapping_origin\camera_model_d3.
+           perspective_of_volume.view_window.size_in_y > 0);
+	WR6 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+            'AXIS2_PLACEMENT_2D' IN TYPEOF (SELF\mapped_item.
+           mapping_target\planar_box.placement))
+           AND NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+           'AXIS2_PLACEMENT_3D' IN TYPEOF (SELF\mapped_item.
+           mapping_target\planar_box.placement));
+END_ENTITY;
+
+
+ENTITY camera_model
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (geometric_representation_item);
+WHERE
+	WR1 : (SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                  'ITEM_DEFINED_TRANSFORMATION.' +
+                                  'TRANSFORM_ITEM_1')) +
+            SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                  'REPRESENTATION_MAP.MAPPING_ORIGIN'))
+            ) > 0;
+	WR2 : SIZEOF(USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                              'STYLED_ITEM.ITEM')) = 0;
+END_ENTITY;
+
+
+ENTITY camera_model_d3
+	SUBTYPE OF (camera_model);
+	view_reference_system : axis2_placement_3d;
+	perspective_of_volume : view_volume;
+WHERE
+	WR1 : (dot_product (SELF.view_reference_system.p[3],
+           SELF.perspective_of_volume.view_window.placement.p[3]) = 1.0)
+           AND
+           (SELF.view_reference_system.location.coordinates[3] =
+           SELF.perspective_of_volume.view_window.
+             placement.location.coordinates[3]);
+	WR2 : SELF\geometric_representation_item.dim = 3;
+END_ENTITY;
+
+
+ENTITY camera_model_d3_multi_clipping
+	SUBTYPE OF (camera_model_d3);
+	shape_clipping : SET [1:?] OF camera_model_d3_multi_clipping_interection_select;
+END_ENTITY;
+
+
+ENTITY camera_model_d3_multi_clipping_intersection
+	SUBTYPE OF (geometric_representation_item);
+	shape_clipping : SET [2:?] OF camera_model_d3_multi_clipping_interection_select;
+END_ENTITY;
+
+
+ENTITY camera_model_d3_multi_clipping_union
+	SUBTYPE OF (geometric_representation_item);
+	shape_clipping : SET [2:?] OF camera_model_d3_multi_clipping_union_select;
+END_ENTITY;
+
+
+ENTITY camera_model_d3_with_hlhsr
+	SUBTYPE OF (camera_model_d3);
+	hidden_line_surface_removal : BOOLEAN;
+END_ENTITY;
+
+
+ENTITY camera_model_with_light_sources
+	SUBTYPE OF (camera_model_d3);
+	sources : SET [1:?] OF light_source;
+END_ENTITY;
+
+
+ENTITY camera_usage
+	SUBTYPE OF (representation_map);
+	SELF\representation_map.mapping_origin : camera_model;
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_REPRESENTATION'
+          IN TYPEOF(SELF\representation_map.mapped_representation));
+END_ENTITY;
+
+
+ENTITY capacitance_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CAPACITANCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY capacitance_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.farad);
+END_ENTITY;
+
+
+ENTITY cartesian_point
+	SUBTYPE OF (point);
+	coordinates : LIST [1:3] OF length_measure;
+END_ENTITY;
+
+
+ENTITY cartesian_transformation_operator
+	SUPERTYPE OF (ONEOF (cartesian_transformation_operator_2d, cartesian_transformation_operator_3d))
+	SUBTYPE OF (geometric_representation_item, functionally_defined_transformation);
+	axis1 : OPTIONAL direction;
+	axis2 : OPTIONAL direction;
+	local_origin : cartesian_point;
+	scale : OPTIONAL REAL;
+DERIVE
+	scl : REAL := NVL(scale, 1.0);
+WHERE
+	WR1 : scl > 0.0;
+END_ENTITY;
+
+
+ENTITY cartesian_transformation_operator_2d
+	SUBTYPE OF (cartesian_transformation_operator);
+DERIVE
+	u : LIST [2:2] OF direction := base_axis(2,SELF\cartesian_transformation_operator.axis1,
+                   SELF\cartesian_transformation_operator.axis2,?);
+WHERE
+	WR1 : SELF\geometric_representation_item.dim = 2;
+END_ENTITY;
+
+
+ENTITY cartesian_transformation_operator_3d
+	SUBTYPE OF (cartesian_transformation_operator);
+	axis3 : OPTIONAL direction;
+DERIVE
+	u : LIST [3:3] OF direction := base_axis(3,SELF\cartesian_transformation_operator.axis1,
+                        SELF\cartesian_transformation_operator.axis2,axis3);
+WHERE
+	WR1 : SELF\geometric_representation_item.dim = 3;
+END_ENTITY;
+
+
+ENTITY cc_design_approval
+	SUBTYPE OF (approval_assignment);
+	items : SET [1:?] OF approved_item;
+END_ENTITY;
+
+
+ENTITY cc_design_certification
+	SUBTYPE OF (certification_assignment);
+	items : SET [1:?] OF certified_item;
+END_ENTITY;
+
+
+ENTITY cc_design_contract
+	SUBTYPE OF (contract_assignment);
+	items : SET [1:?] OF contracted_item;
+END_ENTITY;
+
+
+ENTITY cc_design_date_and_time_assignment
+	SUBTYPE OF (date_and_time_assignment);
+	items : SET [1:?] OF date_time_item;
+END_ENTITY;
+
+
+ENTITY cc_design_person_and_organization_assignment
+	SUBTYPE OF (person_and_organization_assignment);
+	items : SET [1:?] OF cc_person_organization_item;
+WHERE
+	WR1 : cc_design_person_and_organization_correlation(SELF);
+END_ENTITY;
+
+
+ENTITY cc_design_security_classification
+	SUBTYPE OF (security_classification_assignment);
+	items : SET [1:?] OF cc_classified_item;
+END_ENTITY;
+
+
+ENTITY cc_design_specification_reference
+	SUBTYPE OF (document_reference);
+	items : SET [1:?] OF cc_specified_item;
+END_ENTITY;
+
+
+ENTITY celsius_temperature_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.THERMODYNAMIC_TEMPERATURE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY centre_of_symmetry
+	SUBTYPE OF (derived_shape_aspect);
+WHERE
+	WR1 : SIZEOF
+        (QUERY(sadr<*SELF\derived_shape_aspect.deriving_relationships|
+    NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SYMMETRIC_SHAPE_ASPECT'
+     IN TYPEOF
+     (sadr\shape_aspect_relationship.related_shape_aspect))))=0;
+END_ENTITY;
+
+
+ENTITY certification;
+	name : label;
+	purpose : text;
+	kind : certification_type;
+END_ENTITY;
+
+
+ENTITY certification_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_certification : certification;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY certification_type;
+	description : label;
+END_ENTITY;
+
+
+ENTITY change
+	SUBTYPE OF (action_assignment);
+	items : SET [1:?] OF work_item;
+END_ENTITY;
+
+
+ENTITY change_request
+	SUBTYPE OF (action_request_assignment);
+	items : SET [1:?] OF change_request_item;
+END_ENTITY;
+
+
+ENTITY character_glyph_font_usage;
+	character : generic_character_glyph_symbol;
+	font : text_font;
+END_ENTITY;
+
+
+ENTITY character_glyph_style_outline
+	SUBTYPE OF (founded_item);
+	outline_style : curve_style;
+END_ENTITY;
+
+
+ENTITY character_glyph_style_stroke
+	SUBTYPE OF (founded_item);
+	stroke_style : curve_style;
+END_ENTITY;
+
+
+ENTITY character_glyph_symbol
+	SUBTYPE OF (generic_character_glyph_symbol);
+	character_box : planar_extent;
+	baseline_ratio : ratio_measure;
+DERIVE
+	box_height : length_measure := character_box.size_in_y;
+WHERE
+	WR1 : {0.0 <= baseline_ratio <= 1.0};
+	WR2 : item_in_context(SELF.character_box, 
+                       SELF\representation.context_of_items);
+	WR3 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE'
+        IN TYPEOF (SELF.box_height);
+END_ENTITY;
+
+
+ENTITY character_glyph_symbol_outline
+	SUBTYPE OF (character_glyph_symbol);
+	outlines : SET [1:?] OF annotation_fill_area;
+WHERE
+	WR1 : SELF.outlines <= SELF\representation.items;
+END_ENTITY;
+
+
+ENTITY character_glyph_symbol_stroke
+	SUBTYPE OF (character_glyph_symbol);
+	strokes : SET [1:?] OF curve;
+WHERE
+	WR1 : SELF.strokes <= SELF\representation.items;
+END_ENTITY;
+
+
+ENTITY characteristic_data_column_header
+	SUBTYPE OF (general_property);
+END_ENTITY;
+
+
+ENTITY characteristic_data_column_header_link
+	SUBTYPE OF (general_property_relationship);
+END_ENTITY;
+
+
+ENTITY characteristic_data_table_header
+	SUBTYPE OF (general_property);
+END_ENTITY;
+
+
+ENTITY characteristic_data_table_header_decomposition
+	SUBTYPE OF (general_property_relationship);
+END_ENTITY;
+
+
+ENTITY characteristic_type
+	SUBTYPE OF (group);
+END_ENTITY;
+
+
+ENTITY characterized_class
+	SUBTYPE OF (characterized_object, class);
+END_ENTITY;
+
+
+ENTITY characterized_object;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY circle
+	SUBTYPE OF (conic);
+	radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY circular_runout_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 2;
+END_ENTITY;
+
+
+ENTITY class
+	SUBTYPE OF (group);
+END_ENTITY;
+
+
+ENTITY class_by_extension
+	SUBTYPE OF (class);
+END_ENTITY;
+
+
+ENTITY class_by_intension
+	SUBTYPE OF (class);
+END_ENTITY;
+
+
+ENTITY class_system
+	SUBTYPE OF (group);
+END_ENTITY;
+
+
+ENTITY class_usage_effectivity_context_assignment
+	SUBTYPE OF (effectivity_context_assignment);
+	items : SET [1:?] OF class_usage_effectivity_context_item;
+WHERE
+	WR1 : SELF.role.name = 'class usage influence';
+	WR2 : SIZEOF( QUERY( i <* SELF.items | NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF(i)) )) = 0;
+	WR3 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.APPLIED_EFFECTIVITY_ASSIGNMENT' IN TYPEOF(SELF.assigned_effectivity_assignment)) AND 
+        (SIZEOF(TYPEOF(SELF.assigned_effectivity_assignment.assigned_effectivity) ) = 1) AND 
+        (SELF.assigned_effectivity_assignment.assigned_effectivity.id = 'class usage') AND 
+        (SIZEOF( QUERY( i <* SELF.assigned_effectivity_assignment\applied_effectivity_assignment.items | 
+        NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_CONCEPT_FEATURE_CATEGORY_USAGE' IN TYPEOF(i)) )) = 0);
+END_ENTITY;
+
+
+ENTITY classification_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_class : group;
+	role : classification_role;
+END_ENTITY;
+
+
+ENTITY classification_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY closed_shell
+	SUBTYPE OF (connected_face_set);
+END_ENTITY;
+
+
+ENTITY coaxiality_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 2;
+END_ENTITY;
+
+
+ENTITY colour;
+END_ENTITY;
+
+
+ENTITY colour_rgb
+	SUBTYPE OF (colour_specification);
+	red : REAL;
+	green : REAL;
+	blue : REAL;
+WHERE
+	WR1 : {0.0 <= red <= 1.0};
+	WR2 : {0.0 <= green <= 1.0};
+	WR3 : {0.0 <= blue <= 1.0};
+END_ENTITY;
+
+
+ENTITY colour_specification
+	SUBTYPE OF (colour);
+	name : label;
+END_ENTITY;
+
+
+ENTITY common_datum
+	SUBTYPE OF (composite_shape_aspect, datum);
+WHERE
+	WR1 : SIZEOF (SELF\composite_shape_aspect.component_relationships) = 2;
+	WR2 : SIZEOF (QUERY ( sar <* SELF\composite_shape_aspect.component_relationships| 
+                      NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DATUM' IN TYPEOF (sar.related_shape_aspect)) AND 
+                          NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMMON_DATUM' IN TYPEOF (sar.related_shape_aspect))) )) = 0;
+END_ENTITY;
+
+
+ENTITY comparison_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (boolean_expression, binary_generic_expression);
+	SELF\binary_generic_expression.operands : LIST [2:2] OF expression;
+WHERE
+	WR1 : (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NUMERIC_EXPRESSION' 
+IN TYPEOF(SELF\binary_generic_expression.operands[1]))
+		AND 
+		 	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NUMERIC_EXPRESSION' 
+IN TYPEOF(SELF\binary_generic_expression.operands[2]))) 
+OR
+ (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOOLEAN_EXPRESSION' 
+IN TYPEOF(SELF\binary_generic_expression.operands[1]))
+		AND 
+		 	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOOLEAN_EXPRESSION' 
+	IN TYPEOF(SELF\binary_generic_expression.operands[2])))
+OR
+(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_EXPRESSION' 
+IN TYPEOF(SELF\binary_generic_expression.operands[1]))
+		AND 
+		 	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_EXPRESSION' 
+IN TYPEOF(SELF\binary_generic_expression.operands[2])));
+END_ENTITY;
+
+
+ENTITY complex_clause
+	SUBTYPE OF (compound_representation_item);
+END_ENTITY;
+
+
+ENTITY complex_conjunctive_clause
+	SUBTYPE OF (complex_clause);
+END_ENTITY;
+
+
+ENTITY complex_disjunctive_clause
+	SUBTYPE OF (complex_clause);
+END_ENTITY;
+
+
+ENTITY complex_shelled_solid
+	SUBTYPE OF (shelled_solid);
+	thickened_face_list : LIST [1:?] OF SET [1:?] OF face_surface;
+	thickness_list : LIST [1:?] OF length_measure;
+WHERE
+	WR1 : SIZEOF(thickened_face_list) = SIZEOF(thickness_list);
+	WR2 : SIZEOF(QUERY(q <* thickness_list | (q = 0))) = 0;
+END_ENTITY;
+
+
+ENTITY composite_assembly_definition
+	SUBTYPE OF (product_definition);
+WHERE
+	WR1 : SIZEOF (QUERY (pdr <* USEDIN (SELF, 
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'PRODUCT_DEFINITION_RELATIONSHIP.' +
+                             'RELATING_PRODUCT_DEFINITION') |
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'NEXT_ASSEMBLY_USAGE_OCCURRENCE' IN
+                             TYPEOF (pdr))) = 1;
+END_ENTITY;
+
+
+ENTITY composite_assembly_sequence_definition
+	SUBTYPE OF (product_definition);
+WHERE
+	WR1 : SIZEOF (QUERY (pdr <* USEDIN (SELF, 
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'PRODUCT_DEFINITION_RELATIONSHIP.' +
+                             'RELATING_PRODUCT_DEFINITION') |
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'NEXT_ASSEMBLY_USAGE_OCCURRENCE' IN
+                             TYPEOF (pdr))) > 0;
+END_ENTITY;
+
+
+ENTITY composite_assembly_table
+	SUBTYPE OF (part_laminate_table);
+END_ENTITY;
+
+
+ENTITY composite_curve
+	SUBTYPE OF (bounded_curve);
+	segments : LIST [1:?] OF composite_curve_segment;
+	self_intersect : LOGICAL;
+DERIVE
+	closed_curve : LOGICAL := segments[n_segments].transition <> discontinuous;
+	n_segments : INTEGER := SIZEOF(segments);
+WHERE
+	WR1 : ((NOT closed_curve) AND (SIZEOF(QUERY(temp <* segments |
+                temp.transition = discontinuous)) = 1)) OR
+            ((closed_curve) AND (SIZEOF(QUERY(temp <* segments | 
+                temp.transition = discontinuous)) = 0));
+END_ENTITY;
+
+
+ENTITY composite_curve_on_surface
+	SUPERTYPE OF (boundary_curve)
+	SUBTYPE OF (composite_curve);
+DERIVE
+	basis_surface : SET [0:2] OF surface := get_basis_surface(SELF);
+WHERE
+	WR1 : SIZEOF(basis_surface) > 0;
+	WR2 : constraints_composite_curve_on_surface(SELF);
+END_ENTITY;
+
+
+ENTITY composite_curve_segment
+	SUBTYPE OF (founded_item);
+	transition : transition_code;
+	same_sense : BOOLEAN;
+	parent_curve : curve;
+INVERSE
+	using_curves: BAG [1:?] OF composite_curve FOR segments;
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_CURVE' IN TYPEOF(parent_curve));
+END_ENTITY;
+
+
+ENTITY composite_material_designation
+	SUBTYPE OF (material_designation);
+END_ENTITY;
+
+
+ENTITY composite_shape_aspect
+	SUBTYPE OF (shape_aspect);
+INVERSE
+	component_relationships: SET [2:?] OF shape_aspect_relationship FOR relating_shape_aspect;
+END_ENTITY;
+
+
+ENTITY composite_sheet_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'MANIFOLD_SURFACE_SHAPE_REPRESENTATION'] * TYPEOF (SELF)) = 1;
+END_ENTITY;
+
+
+ENTITY composite_text
+	SUBTYPE OF (geometric_representation_item);
+	collected_text : SET [2:?] OF text_or_character;
+WHERE
+	WR1 : acyclic_composite_text( SELF, SELF.collected_text);
+END_ENTITY;
+
+
+ENTITY composite_text_with_associated_curves
+	SUBTYPE OF (composite_text);
+	associated_curves : SET [1:?] OF curve;
+END_ENTITY;
+
+
+ENTITY composite_text_with_blanking_box
+	SUBTYPE OF (composite_text);
+	blanking : planar_box;
+END_ENTITY;
+
+
+ENTITY composite_text_with_delineation
+	SUBTYPE OF (composite_text);
+	delineation : text_delineation;
+END_ENTITY;
+
+
+ENTITY composite_text_with_extent
+	SUBTYPE OF (composite_text);
+	extent : planar_extent;
+END_ENTITY;
+
+
+ENTITY compound_representation_item
+	SUPERTYPE OF (ONEOF (point_and_vector, point_path, row_representation_item, table_representation_item))
+	SUBTYPE OF (representation_item);
+	item_element : compound_item_definition;
+END_ENTITY;
+
+
+ENTITY compound_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'GEOMETRIC_REPRESENTATION_CONTEXT'
+        IN TYPEOF ( SELF.context_of_items ) ) AND (
+        SELF.context_of_items\
+        geometric_representation_context.coordinate_space_dimension =3 );
+	WR2 : SIZEOF ( QUERY ( cbsr_i <* SELF.items | SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'EDGE_BASED_WIREFRAME_MODEL' ,
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'FACE_BASED_SURFACE_MODEL' ,
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MAPPED_ITEM' , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+         'AXIS2_PLACEMENT_3D']* TYPEOF ( cbsr_i ) ) <>1 ) ) =0;
+	WR3 : SIZEOF ( QUERY ( cbsr_i <* SELF.items | SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'EDGE_BASED_WIREFRAME_MODEL' ,
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'FACE_BASED_SURFACE_MODEL' ,
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MAPPED_ITEM']* TYPEOF ( cbsr_i ) ) =1 ) ) >0;
+	WR4 : SIZEOF ( QUERY ( cbsr_i <* SELF.items | (
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MAPPED_ITEM' IN TYPEOF ( cbsr_i ) )
+         AND ( SIZEOF ( ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+         'COMPOUND_SHAPE_REPRESENTATION' , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+         'EDGE_BASED_WIREFRAME_SHAPE_REPRESENTATION' ,
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+         'NON_MANIFOLD_SURFACE_SHAPE_REPRESENTATION']* TYPEOF (
+         cbsr_i\ mapped_item.mapping_source ) ) <>1 ) ) ) =0;
+END_ENTITY;
+
+
+ENTITY concentricity_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) = 1;
+END_ENTITY;
+
+
+ENTITY concept_feature_operator;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY concept_feature_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_product_concept_feature : product_concept_feature;
+	related_product_concept_feature : product_concept_feature;
+END_ENTITY;
+
+
+ENTITY concept_feature_relationship_with_condition
+	SUBTYPE OF (concept_feature_relationship);
+	conditional_operator : concept_feature_operator;
+END_ENTITY;
+
+
+ENTITY conditional_concept_feature
+	SUBTYPE OF (product_concept_feature);
+	condition : concept_feature_relationship_with_condition;
+END_ENTITY;
+
+
+ENTITY conductance_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONDUCTANCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY conductance_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.siemens);
+END_ENTITY;
+
+
+ENTITY configurable_item
+	SUBTYPE OF (configuration_item);
+	item_concept_feature : SET [1:?] OF product_concept_feature_association;
+END_ENTITY;
+
+
+ENTITY configuration_design;
+	configuration : configuration_item;
+	design : configuration_design_item;
+DERIVE
+	description : text := get_description_value (SELF);
+	name : label := get_name_value (SELF);
+UNIQUE
+	UR1 : configuration, design;
+WHERE
+	WR1 : SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+	WR2 : SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY configuration_effectivity
+	SUBTYPE OF (product_definition_effectivity);
+	configuration : configuration_design;
+UNIQUE
+  UR1: configuration, SELF\product_definition_effectivity.usage, SELF\effectivity.id;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_USAGE' IN
+        TYPEOF (SELF\product_definition_effectivity.usage);
+END_ENTITY;
+
+
+ENTITY configuration_item;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+	item_concept : product_concept;
+	purpose : OPTIONAL label;
+END_ENTITY;
+
+
+ENTITY configuration_item_hierarchical_relationship
+	SUBTYPE OF (configuration_item_relationship);
+END_ENTITY;
+
+
+ENTITY configuration_item_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_configuration_item : configuration_item;
+	related_configuration_item : configuration_item;
+END_ENTITY;
+
+
+ENTITY configuration_item_revision_sequence
+	SUBTYPE OF (configuration_item_relationship);
+END_ENTITY;
+
+
+ENTITY configured_effectivity_assignment
+	SUBTYPE OF (effectivity_assignment);
+	items : SET [1:?] OF configured_effectivity_item;
+WHERE
+	WR1 : (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EFFECTIVITY'] * TYPEOF(SELF.assigned_effectivity) ) = 1) 
+	AND (SELF.assigned_effectivity.id = 'configuration validity');
+	WR2 : SIZEOF(SELF.items) = 1;
+	WR3 : SIZEOF( QUERY( i <* SELF.items | NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF(i)) 
+	OR NOT (i\product_definition.frame_of_reference.name IN ['conceptual definition','part occurrence', 'functional definition','alternative definition']) )) = 0;
+	WR4 : SELF.role.name IN ['design', 'usage'];
+	WR5 : (SELF.role.name <> 'design') 
+	OR (SIZEOF( QUERY( i <* SELF.items | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF(i)) AND (i\product_definition.frame_of_reference.name = 'part occurrence') )) = 0);
+	WR6 : (SELF.role.name <> 'usage') OR (SIZEOF( QUERY( i <* SELF.items | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF(i)) AND (i\product_definition.frame_of_reference.name = 'conceptual definition') )) = 0);
+	WR7 : SELF.role.description IN ['exception', 'inherited', 'local'];
+	WR8 : SIZEOF( QUERY( x <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'EFFECTIVITY_CONTEXT_ASSIGNMENT.ASSIGNED_EFFECTIVITY_ASSIGNMENT') | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONFIGURED_EFFECTIVITY_CONTEXT_ASSIGNMENT' IN TYPEOF(x) )) = 1;
+END_ENTITY;
+
+
+ENTITY configured_effectivity_context_assignment
+	SUBTYPE OF (effectivity_context_assignment);
+	items : SET [1:?] OF configured_effectivity_context_item;
+	SELF\effectivity_context_assignment.assigned_effectivity_assignment : configured_effectivity_assignment;
+WHERE
+	WR1 : SIZEOF(SELF.items) = 1;
+END_ENTITY;
+
+
+ENTITY conic
+	SUPERTYPE OF (ONEOF (circle, ellipse, hyperbola, parabola))
+	SUBTYPE OF (curve);
+	position : axis2_placement;
+END_ENTITY;
+
+
+ENTITY conical_stepped_hole_transition
+	SUBTYPE OF (geometric_representation_item);
+	transition_number : positive_integer;
+	cone_apex_angle : plane_angle_measure;
+	cone_base_radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY conical_surface
+	SUBTYPE OF (elementary_surface);
+	radius : length_measure;
+	semi_angle : plane_angle_measure;
+WHERE
+	WR1 : radius >= 0.0;
+END_ENTITY;
+
+
+ENTITY connected_edge_set
+	SUBTYPE OF (topological_representation_item);
+	ces_edges : SET [1:?] OF edge;
+END_ENTITY;
+
+
+ENTITY connected_face_set
+	SUPERTYPE OF (ONEOF (closed_shell, open_shell))
+	SUBTYPE OF (topological_representation_item);
+	cfs_faces : SET [1:?] OF face;
+END_ENTITY;
+
+
+ENTITY connected_face_sub_set
+	SUBTYPE OF (connected_face_set);
+	parent_face_set : connected_face_set;
+END_ENTITY;
+
+
+ENTITY constructive_geometry_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_CONTEXT' IN TYPEOF(SELF.context_of_items)) AND ({2 <= SELF.context_of_items\geometric_representation_context. coordinate_space_dimension <= 3});
+	WR2 : SIZEOF( QUERY( cgr_i <* SELF.items | SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLACEMENT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT'] * TYPEOF(cgr_i)) <> 1 )) = 0;
+	WR3 : SIZEOF( USEDIN( SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION_RELATIONSHIP.REP_2') ) > 0;
+	WR4 : SIZEOF( USEDIN( SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION_MAP.MAPPED_REPRESENTATION') ) = 0;
+END_ENTITY;
+
+
+ENTITY constructive_geometry_representation_relationship
+	SUBTYPE OF (representation_relationship);
+	SELF\representation_relationship.rep_1 : constructive_geometry_representation_or_shape_represenation;
+	SELF\representation_relationship.rep_2 : constructive_geometry_representation;
+WHERE
+	WR1 : (SELF.rep_1.context_of_items :=: SELF.rep_2.context_of_items) AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_CONTEXT' IN TYPEOF(SELF.rep_1.context_of_items));
+	WR2 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION' IN TYPEOF(SELF));
+END_ENTITY;
+
+
+ENTITY contact_ratio_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : ( SIZEOF ( SELF.items ) =1 ) AND ( SIZEOF ( QUERY ( i <*
+        SELF.items | ( SIZEOF ( ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'MEASURE_REPRESENTATION_ITEM' , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'VALUE_RANGE']* TYPEOF ( i ) ) =1 ) AND ( i.name =
+        'ratio value' ) ) ) =1 );
+	WR2 : ( SIZEOF ( QUERY ( pdr <* USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) | pdr. name =
+        'contact ratio reference' ) ) =1 ) AND ( SIZEOF ( QUERY (
+        pdr <* USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) | ( pdr. name =
+        'contact ratio reference' ) AND ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'PRODUCT_DEFINITION' IN TYPEOF ( pdr.
+        definition.definition ) ) ) ) =1 );
+	WR3 : ( SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) ) =1 ) AND ( SIZEOF ( QUERY ( pdr
+        <* USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) | SIZEOF ( QUERY ( gpa <* USEDIN (
+        pdr. definition ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'GENERAL_PROPERTY_ASSOCIATION.'+
+        'DERIVED_DEFINITION' ) | ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'GENERAL_PROPERTY' IN TYPEOF ( gpa. base_definition ) ) AND
+        ( gpa. base_definition.name ='surface_condition' ) ) ) =1 )
+        ) =1 );
+END_ENTITY;
+
+
+ENTITY context_dependent_invisibility
+	SUBTYPE OF (invisibility);
+	presentation_context : invisibility_context;
+END_ENTITY;
+
+
+ENTITY context_dependent_over_riding_styled_item
+	SUBTYPE OF (over_riding_styled_item);
+	style_context : LIST [1:?] OF style_context_select;
+WHERE
+	WR1 : (SIZEOF(QUERY(sc <* SELF.style_context | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION_ITEM' IN TYPEOF(sc)))= 1) OR
+(SIZEOF(QUERY(sc <* SELF.style_context |
+     ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF(sc))
+  OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION_RELATIONSHIP' IN TYPEOF(sc)) ))
+  = SIZEOF(style_context));
+END_ENTITY;
+
+
+ENTITY context_dependent_shape_representation;
+	representation_relation : shape_representation_relationship;
+	represented_product_relation : product_definition_shape;
+DERIVE
+	description : text := get_description_value(SELF);
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_RELATIONSHIP' IN TYPEOF(SELF.represented_product_relation.definition);
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+	WR3 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY context_dependent_unit
+	SUBTYPE OF (named_unit);
+	name : label;
+END_ENTITY;
+
+
+ENTITY contract;
+	name : label;
+	purpose : text;
+	kind : contract_type;
+END_ENTITY;
+
+
+ENTITY contract_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_contract : contract;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY contract_relationship;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+	relating_contract : contract;
+	related_contract : contract;
+END_ENTITY;
+
+
+ENTITY contract_type;
+	description : label;
+END_ENTITY;
+
+
+ENTITY conversion_based_unit
+	SUBTYPE OF (named_unit);
+	name : label;
+	conversion_factor : measure_with_unit;
+WHERE
+	WR1 : SELF\named_unit.dimensions = derive_dimensional_exponents(conversion_factor\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY coordinated_universal_time_offset;
+	hour_offset : INTEGER;
+	minute_offset : OPTIONAL INTEGER;
+	sense : ahead_or_behind;
+DERIVE
+	actual_minute_offset : INTEGER := NVL(minute_offset,0);
+WHERE
+	WR1 : { 0 <= hour_offset < 24 };
+	WR2 : { 0 <= actual_minute_offset <= 59 };
+	WR3 : NOT (((hour_offset <> 0) OR (actual_minute_offset <>0)) AND (sense = exact));
+END_ENTITY;
+
+
+ENTITY csg_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SELF.context_of_items\geometric_representation_context.coordinate_space_dimension = 3;
+	WR2 : SIZEOF ( 
+QUERY ( it <* SELF.items| ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CSG_SOLID', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_REPLICA', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REVOLVED_FACE_SOLID', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EXTRUDED_FACE_SOLID' ] * TYPEOF (it)) <> 1) )) = 0;
+	WR3 : SIZEOF ( 
+QUERY ( mi <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CSG_SHAPE_REPRESENTATION' IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation)) )) = 0;
+	WR4 : SIZEOF ( 
+QUERY ( sr <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_REPLICA' IN TYPEOF (it)) )| ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CSG_SOLID', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REVOLVED_FACE_SOLID', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EXTRUDED_FACE_SOLID' ] * TYPEOF (sr\solid_replica.parent_solid)) = 0) )) = 0;
+	WR5 : SIZEOF ( 
+QUERY ( it <* SELF.items| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D' IN TYPEOF (it)) )) > 0;
+END_ENTITY;
+
+
+ENTITY csg_solid
+	SUBTYPE OF (solid_model);
+	tree_root_expression : csg_select;
+END_ENTITY;
+
+
+ENTITY currency
+	ABSTRACT SUPERTYPE OF (ONEOF (externally_defined_currency, iso4217_currency))
+	SUBTYPE OF (context_dependent_unit);
+WHERE
+	WR1 : ((SELF\named_unit.dimensions.length_exponent = 0.0) AND
+           (SELF\named_unit.dimensions.mass_exponent = 0.0) AND
+           (SELF\named_unit.dimensions.time_exponent = 0.0) AND
+           (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND
+           (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND
+           (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND
+           (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0));
+END_ENTITY;
+
+
+ENTITY currency_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+	SELF\measure_with_unit.unit_component : currency;
+END_ENTITY;
+
+
+ENTITY curve
+	SUPERTYPE OF (ONEOF (line, conic, pcurve, surface_curve, offset_curve_2d, offset_curve_3d, curve_replica))
+	SUBTYPE OF (geometric_representation_item);
+END_ENTITY;
+
+
+ENTITY curve_bounded_surface
+	SUBTYPE OF (bounded_surface);
+	basis_surface : surface;
+	boundaries : SET [1:?] OF boundary_curve;
+	implicit_outer : BOOLEAN;
+WHERE
+	WR1 : (NOT implicit_outer) OR
+         (SIZEOF (QUERY (temp <* boundaries |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OUTER_BOUNDARY_CURVE' IN TYPEOF(temp))) = 0);
+	WR2 : (NOT(implicit_outer)) OR
+                ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_SURFACE' IN TYPEOF(basis_surface));
+	WR3 : SIZEOF(QUERY(temp <* boundaries |
+                  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OUTER_BOUNDARY_CURVE' IN
+                                         TYPEOF(temp))) <= 1;
+	WR4 : SIZEOF(QUERY(temp <* boundaries |
+            (temp\composite_curve_on_surface.basis_surface [1] <>
+                                         SELF.basis_surface))) = 0;
+END_ENTITY;
+
+
+ENTITY curve_dimension
+	SUBTYPE OF (dimension_curve_directed_callout);
+END_ENTITY;
+
+
+ENTITY curve_replica
+	SUBTYPE OF (curve);
+	parent_curve : curve;
+	transformation : cartesian_transformation_operator;
+WHERE
+	WR1 : transformation.dim = parent_curve.dim;
+	WR2 : acyclic_curve_replica (SELF, parent_curve);
+END_ENTITY;
+
+
+ENTITY curve_style
+	SUBTYPE OF (founded_item);
+	name : label;
+	curve_font : curve_font_or_scaled_curve_font_select;
+	curve_width : size_select;
+	curve_colour : colour;
+END_ENTITY;
+
+
+ENTITY curve_style_font
+	SUBTYPE OF (founded_item);
+	name : label;
+	pattern_list : LIST [1:?] OF curve_style_font_pattern;
+END_ENTITY;
+
+
+ENTITY curve_style_font_and_scaling
+	SUBTYPE OF (founded_item);
+	name : label;
+	curve_font : curve_style_font_select;
+	curve_font_scaling : REAL;
+END_ENTITY;
+
+
+ENTITY curve_style_font_pattern
+	SUBTYPE OF (founded_item);
+	visible_segment_length : positive_length_measure;
+	invisible_segment_length : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY curve_style_rendering;
+	rendering_method : shading_curve_method;
+	rendering_properties : surface_rendering_properties;
+END_ENTITY;
+
+
+ENTITY curve_swept_solid_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF (QUERY (it <* SELF.items |
+          NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_AREA_SOLID',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_DISK_SOLID',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D'] *
+                   TYPEOF(it)) = 1))) = 0;
+	WR2 : SIZEOF (QUERY (it <* SELF.items |
+         SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_AREA_SOLID',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_DISK_SOLID',
+          'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'] * TYPEOF(it)) =1 )) > 0;
+	WR3 : SIZEOF (QUERY (mi <*  QUERY (it <* items |
+                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF(it)) |
+   NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_SWEPT_SOLID_SHAPE_REPRESENTATION' IN
+             TYPEOF(mi\mapped_item.mapping_source.
+                           mapped_representation)))) = 0;
+	WR4 : SIZEOF (QUERY (scsas <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE_SWEPT_AREA_SOLID' IN
+              TYPEOF(it)) |
+          NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN
+                 TYPEOF(scsas\surface_curve_swept_area_solid.directrix)) OR
+                   ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN
+                   TYPEOF(scsas\surface_curve_swept_area_solid.directrix))))) = 0;
+END_ENTITY;
+
+
+ENTITY cylindrical_surface
+	SUBTYPE OF (elementary_surface);
+	radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY cylindricity_tolerance
+	SUBTYPE OF (geometric_tolerance);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE' IN TYPEOF (SELF));
+END_ENTITY;
+
+
+ENTITY data_environment;
+	name : label;
+	description : text;
+	elements : SET [1:?] OF property_definition_representation;
+END_ENTITY;
+
+
+ENTITY date
+	SUPERTYPE OF (ONEOF (calendar_date, ordinal_date, week_of_year_and_day_date, year_month));
+	year_component : year_number;
+END_ENTITY;
+
+
+ENTITY date_and_time;
+	date_component : date;
+	time_component : local_time;
+END_ENTITY;
+
+
+ENTITY date_and_time_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_date_and_time : date_and_time;
+	role : date_time_role;
+END_ENTITY;
+
+
+ENTITY date_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_date : date;
+	role : date_role;
+END_ENTITY;
+
+
+ENTITY date_representation_item
+	SUBTYPE OF (representation_item, date);
+END_ENTITY;
+
+
+ENTITY date_role;
+	name : label;
+DERIVE
+	description : text := get_description_value (SELF);
+WHERE
+	WR1 : SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY date_time_representation_item
+	SUBTYPE OF (representation_item, date_and_time);
+END_ENTITY;
+
+
+ENTITY date_time_role;
+	name : label;
+DERIVE
+	description : text := get_description_value (SELF);
+WHERE
+	WR1 : SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY dated_effectivity
+	SUBTYPE OF (effectivity);
+	effectivity_end_date : OPTIONAL date_time_or_event_occurrence;
+	effectivity_start_date : date_time_or_event_occurrence;
+END_ENTITY;
+
+
+ENTITY datum
+	SUBTYPE OF (shape_aspect);
+	identification : identifier;
+INVERSE
+	established_by_relationships: SET [1:?] OF shape_aspect_relationship FOR related_shape_aspect;
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMMON_DATUM' IN TYPEOF(SELF)) XOR
+       ((SIZEOF(QUERY(x <* SELF\datum.established_by_relationships |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DATUM_FEATURE' IN TYPEOF(x\shape_aspect_relationship.relating_shape_aspect)))) = 1) XOR
+       (SIZEOF(QUERY(x <* SELF\datum.established_by_relationships |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DATUM_TARGET' IN TYPEOF(x\shape_aspect_relationship.relating_shape_aspect)))) >= 1));
+END_ENTITY;
+
+
+ENTITY datum_feature
+	SUBTYPE OF (shape_aspect);
+INVERSE
+	feature_basis_relationship: SET [1:?] OF shape_aspect_relationship FOR relating_shape_aspect;
+WHERE
+	WR1 : SIZEOF(QUERY(sar <* SELF\datum_feature.feature_basis_relationship 
+       | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DATUM' IN TYPEOF
+       (sar\shape_aspect_relationship.related_shape_aspect)))) = 1;
+	WR2 : SELF\shape_aspect.product_definitional = TRUE;
+END_ENTITY;
+
+
+ENTITY datum_feature_callout
+	SUBTYPE OF (draughting_callout);
+END_ENTITY;
+
+
+ENTITY datum_reference;
+	precedence : INTEGER;
+	referenced_datum : datum;
+WHERE
+	WR1 : precedence > 0;
+END_ENTITY;
+
+
+ENTITY datum_target
+	SUBTYPE OF (shape_aspect);
+	target_id : identifier;
+INVERSE
+	target_basis_relationship: SET [1:?] OF shape_aspect_relationship FOR relating_shape_aspect;
+WHERE
+	WR1 : SIZEOF(QUERY(sar <* SELF\datum_target.target_basis_relationship 
+       | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DATUM' IN TYPEOF
+       (sar\shape_aspect_relationship.related_shape_aspect)))) = 1;
+	WR2 : SELF\shape_aspect.product_definitional = TRUE;
+END_ENTITY;
+
+
+ENTITY datum_target_callout
+	SUBTYPE OF (draughting_callout);
+END_ENTITY;
+
+
+ENTITY default_tolerance_table
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : SIZEOF( QUERY( i <* SELF.items | NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEFAULT_TOLERANCE_TABLE_CELL' IN TYPEOF(i)) )) = 0;
+	WR2 : (SIZEOF( QUERY( rr <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION_RELATIONSHIP.REP_1') | rr.name < 'general tolerance definition' )) = 0) AND (SIZEOF( QUERY( rr <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION_RELATIONSHIP.REP_1') | (rr.name = 'general tolerance definition') AND (rr.rep_2.name < 'default tolerance') )) = 0) AND (SIZEOF( USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION_RELATIONSHIP.REP_2') ) = 0);
+END_ENTITY;
+
+
+ENTITY default_tolerance_table_cell
+	SUBTYPE OF (compound_representation_item);
+WHERE
+	WR1 : SIZEOF(QUERY( x <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION.ITEMS') | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DEFAULT_TOLERANCE_TABLE' IN TYPEOF(x)))=1;
+	WR2 : default_tolerance_table_cell_wr2(SELF\compound_representation_item.item_element);
+	WR3 : default_tolerance_table_cell_wr3(SELF\compound_representation_item.item_element);
+	WR4 : default_tolerance_table_cell_wr4(SELF\compound_representation_item.item_element);
+	WR5 : default_tolerance_table_cell_wr5(SELF\compound_representation_item.item_element);
+END_ENTITY;
+
+
+ENTITY defined_symbol
+	SUBTYPE OF (geometric_representation_item);
+	definition : defined_symbol_select;
+	target : symbol_target;
+END_ENTITY;
+
+
+ENTITY definitional_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PARAMETRIC_REPRESENTATION_CONTEXT' IN
+          TYPEOF (SELF\representation.context_of_items );
+END_ENTITY;
+
+
+ENTITY definitional_representation_relationship
+	SUBTYPE OF (representation_relationship);
+WHERE
+	WR1 : acyclic_representation_relationship(SELF,
+         [SELF\representation_relationship.rep_2],
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'REPRESENTATION');
+END_ENTITY;
+
+
+ENTITY definitional_representation_relationship_with_same_context
+	SUBTYPE OF (definitional_representation_relationship);
+WHERE
+	WR1 : SELF\representation_relationship.rep_1.context_of_items :=: 
+            SELF\representation_relationship.rep_2.context_of_items;
+END_ENTITY;
+
+
+ENTITY degenerate_pcurve
+	SUBTYPE OF (point);
+	basis_surface : surface;
+	reference_to_curve : definitional_representation;
+WHERE
+	WR1 : SIZEOF(reference_to_curve\representation.items) = 1;
+	WR2 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE' IN TYPEOF
+                    (reference_to_curve\representation.items[1]);
+	WR3 : reference_to_curve\representation.
+                   items[1]\geometric_representation_item.dim =2;
+END_ENTITY;
+
+
+ENTITY degenerate_toroidal_surface
+	SUBTYPE OF (toroidal_surface);
+	select_outer : BOOLEAN;
+WHERE
+	WR1 : major_radius <   minor_radius;
+END_ENTITY;
+
+
+ENTITY derived_shape_aspect
+	SUPERTYPE OF (ONEOF (apex, centre_of_symmetry, geometric_alignment, geometric_intersection, parallel_offset, perpendicular_to, extension, tangent))
+	SUBTYPE OF (shape_aspect);
+INVERSE
+	deriving_relationships: SET [1:?] OF shape_aspect_relationship FOR relating_shape_aspect;
+WHERE
+	WR1 : SIZEOF (QUERY (dr <*
+          SELF\derived_shape_aspect.deriving_relationships |
+          NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+               'SHAPE_ASPECT_DERIVING_RELATIONSHIP'
+          IN TYPEOF (dr)))) = 0;
+END_ENTITY;
+
+
+ENTITY derived_unit
+	SUPERTYPE OF (ONEOF (absorbed_dose_unit, acceleration_unit, radioactivity_unit, area_unit, capacitance_unit, dose_equivalent_unit, electric_charge_unit, conductance_unit, electric_potential_unit, energy_unit, magnetic_flux_density_unit, force_unit, frequency_unit, illuminance_unit, inductance_unit, magnetic_flux_unit, power_unit, pressure_unit, resistance_unit, velocity_unit, volume_unit));
+	elements : SET [1:?] OF derived_unit_element;
+DERIVE
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : (SIZEOF(elements) > 1) OR ((SIZEOF(elements) = 1) AND (elements[1].exponent <> 1.0));
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY derived_unit_element;
+	unit : named_unit;
+	exponent : REAL;
+END_ENTITY;
+
+
+ENTITY description_attribute;
+	attribute_value : text;
+	described_item : description_attribute_select;
+END_ENTITY;
+
+
+ENTITY descriptive_representation_item
+	SUPERTYPE OF (ONEOF (tagged_text_item, uniform_resource_identifier))
+	SUBTYPE OF (representation_item);
+	description : text;
+END_ENTITY;
+
+
+ENTITY design_context
+	SUBTYPE OF (product_definition_context);
+WHERE
+	WR1 : SELF.life_cycle_stage = 'design';
+END_ENTITY;
+
+
+ENTITY design_make_from_relationship
+	SUBTYPE OF (product_definition_relationship);
+END_ENTITY;
+
+
+ENTITY diameter_dimension
+	SUBTYPE OF (dimension_curve_directed_callout);
+END_ENTITY;
+
+
+ENTITY dielectric_constant_measure_with_unit
+	SUBTYPE OF (ratio_measure_with_unit);
+END_ENTITY;
+
+
+ENTITY dimension_callout
+	SUBTYPE OF (draughting_callout);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_DIRECTED_CALLOUT'
+        IN (TYPEOF (SELF))) XOR
+       (SIZEOF (QUERY(dce_1 <* SELF\draughting_callout.contents |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_CURVE'
+        IN (TYPEOF(dce_1))))) = 0);
+	WR2 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_DIRECTED_CALLOUT'
+        IN (TYPEOF (SELF))) XOR
+       (SIZEOF (QUERY(dce_1 <* SELF\draughting_callout.contents |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_CURVE'
+        IN (TYPEOF(dce_1))))) = 0);
+	WR3 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE_DIRECTED_CALLOUT'
+        IN (TYPEOF (SELF))) XOR
+       (SIZEOF (QUERY(dce_1 <* SELF\draughting_callout.contents |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE'
+        IN (TYPEOF(dce_1))))) = 0);
+END_ENTITY;
+
+
+ENTITY dimension_callout_component_relationship
+	SUBTYPE OF (draughting_callout_relationship);
+WHERE
+	WR1 : SELF.name IN ['prefix', 'suffix'];
+	WR2 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRUCTURED_DIMENSION_CALLOUT'
+           IN TYPEOF (SELF.relating_draughting_callout);
+	WR3 : SIZEOF (TYPEOF (SELF.related_draughting_callout) *
+       ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_DIRECTED_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_DIRECTED_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE_DIRECTED_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRUCTURED_DIMENSION_CALLOUT']) = 0;
+	WR4 : SELF.related_draughting_callout.contents *
+       SELF.relating_draughting_callout.contents =
+       SELF.related_draughting_callout.contents;
+	WR5 : ((SELF.name = 'prefix') AND
+       (SIZEOF (QUERY (ato <* QUERY (con <*
+                 SELF.related_draughting_callout.contents |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF(con))) |
+         NOT (ato.name = 'prefix text')
+       )) = 0));
+	WR6 : ((SELF.name = 'suffix') AND
+       (SIZEOF (QUERY (ato <* QUERY (con <*
+                 SELF.related_draughting_callout.contents |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF(con))) |
+         NOT (ato.name = 'suffix text')
+       )) = 0));
+END_ENTITY;
+
+
+ENTITY dimension_callout_relationship
+	SUBTYPE OF (draughting_callout_relationship);
+WHERE
+	WR1 : SELF.name IN ['primary', 'secondary'];
+	WR2 : SIZEOF (TYPEOF (SELF.relating_draughting_callout) * 
+       ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANGULAR_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIAMETER_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_DIRECTED_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINEAR_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORDINATE_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RADIUS_DIMENSION'])>=1;
+	WR3 : SIZEOF (TYPEOF (SELF.related_draughting_callout) *
+       ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE_DIRECTED_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_DIRECTED_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_DIRECTED_CALLOUT']) = 0;
+	WR4 : SELF.related_draughting_callout.contents *
+       SELF.relating_draughting_callout.contents =
+       SELF.related_draughting_callout.contents;
+END_ENTITY;
+
+
+ENTITY dimension_curve
+	SUBTYPE OF (annotation_curve_occurrence);
+WHERE
+	WR1 : (SIZEOF(
+          QUERY(dct <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                'TERMINATOR_SYMBOL.ANNOTATED_CURVE')
+               | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                  'DIMENSION_CURVE_TERMINATOR' IN TYPEOF(dct))
+                  ))
+          ) <= 2);
+	WR2 : SIZEOF(
+            QUERY( dcdc <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                   'DRAUGHTING_CALLOUT.CONTENTS') |
+                   ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                    'DIMENSION_CURVE_DIRECTED_CALLOUT' IN TYPEOF(dcdc)))
+          )>= 1;
+	WR3 : (SIZEOF(
+            QUERY(dct1 <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                  'TERMINATOR_SYMBOL.ANNOTATED_CURVE') 
+               | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                  'DIMENSION_CURVE_TERMINATOR' IN TYPEOF(dct1)) 
+                  AND (dct1\dimension_curve_terminator.role = dimension_extent_usage.origin)))
+          ) <= 1)
+        AND 
+        (SIZEOF(
+            QUERY (dct2 <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                   'TERMINATOR_SYMBOL.ANNOTATED_CURVE') 
+                 | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                   'DIMENSION_CURVE_TERMINATOR' IN TYPEOF(dct2))
+                   AND (dct2\dimension_curve_terminator.role = dimension_extent_usage.target)))
+         ) <= 1);
+END_ENTITY;
+
+
+ENTITY dimension_curve_directed_callout
+	SUBTYPE OF (draughting_callout);
+WHERE
+	WR1 : SIZEOF(QUERY(d_c<*SELF\draughting_callout.contents | 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE' IN (TYPEOF(d_c))))=1;
+	WR2 : SIZEOF(SELF\draughting_callout.contents) >= 2;
+END_ENTITY;
+
+
+ENTITY dimension_curve_terminator
+	SUBTYPE OF (terminator_symbol);
+	role : dimension_extent_usage;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE' IN TYPEOF
+        (SELF\terminator_symbol.annotated_curve);
+END_ENTITY;
+
+
+ENTITY dimension_curve_terminator_to_projection_curve_associativity
+	SUBTYPE OF (annotation_occurrence_associativity);
+	SELF\annotation_occurrence_relationship.related_annotation_occurrence : projection_curve;
+	SELF\annotation_occurrence_relationship.relating_annotation_occurrence : dimension_curve_terminator;
+END_ENTITY;
+
+
+ENTITY dimension_pair
+	SUBTYPE OF (draughting_callout_relationship);
+WHERE
+	WR1 : SELF.name IN ['chained', 'parallel'];
+	WR2 : SIZEOF (TYPEOF (SELF.relating_draughting_callout) *
+       ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANGULAR_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIAMETER_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINEAR_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORDINATE_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RADIUS_DIMENSION'])=1;
+	WR3 : SIZEOF (TYPEOF (SELF.related_draughting_callout) *
+       ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANGULAR_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIAMETER_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINEAR_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORDINATE_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RADIUS_DIMENSION'])=1;
+END_ENTITY;
+
+
+ENTITY dimension_related_tolerance_zone_element;
+	related_dimension : dimensional_location;
+	related_element : tolerance_zone_definition;
+END_ENTITY;
+
+
+ENTITY dimension_text_associativity
+	SUBTYPE OF (text_literal, mapped_item);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_DIMENSION_REPRESENTATION'
+          IN TYPEOF (SELF\mapped_item.
+                          mapping_source.mapped_representation));
+	WR2 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT'
+          IN TYPEOF (SELF\mapped_item.mapping_target));
+	WR3 : SIZEOF (QUERY (ato <* QUERY (si <* 
+          USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM.ITEM') |
+            ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+              IN TYPEOF(si))) |
+          NOT (SIZEOF( QUERY (dc <*
+             USEDIN (ato, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                          'DRAUGHTING_CALLOUT.CONTENTS') |
+               ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT'
+             IN TYPEOF (dc)))
+            * [SELF\mapped_item.mapping_target]) = 1)
+          )) = 0;
+END_ENTITY;
+
+
+ENTITY dimensional_characteristic_representation;
+	dimension : dimensional_characteristic;
+	representation : shape_dimension_representation;
+END_ENTITY;
+
+
+ENTITY dimensional_exponents;
+	length_exponent : REAL;
+	mass_exponent : REAL;
+	time_exponent : REAL;
+	electric_current_exponent : REAL;
+	thermodynamic_temperature_exponent : REAL;
+	amount_of_substance_exponent : REAL;
+	luminous_intensity_exponent : REAL;
+END_ENTITY;
+
+
+ENTITY dimensional_location
+	SUPERTYPE OF (ONEOF (angular_location, dimensional_location_with_path))
+	SUBTYPE OF (shape_aspect_relationship);
+END_ENTITY;
+
+
+ENTITY dimensional_location_with_path
+	SUBTYPE OF (dimensional_location);
+	path : shape_aspect;
+END_ENTITY;
+
+
+ENTITY dimensional_size
+	SUPERTYPE OF (ONEOF (angular_size, dimensional_size_with_path));
+	applies_to : shape_aspect;
+	name : label;
+WHERE
+	WR1 : applies_to.product_definitional = TRUE;
+END_ENTITY;
+
+
+ENTITY dimensional_size_with_path
+	SUBTYPE OF (dimensional_size);
+	path : shape_aspect;
+END_ENTITY;
+
+
+ENTITY directed_action
+	SUBTYPE OF (executed_action);
+	directive : action_directive;
+END_ENTITY;
+
+
+ENTITY directed_dimensional_location
+	SUBTYPE OF (dimensional_location);
+END_ENTITY;
+
+
+ENTITY direction
+	SUBTYPE OF (geometric_representation_item);
+	direction_ratios : LIST [2:3] OF REAL;
+WHERE
+	WR1 : SIZEOF(QUERY(tmp <* direction_ratios | tmp <> 0.0)) > 0;
+END_ENTITY;
+
+
+ENTITY document;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+	kind : document_type;
+INVERSE
+	representation_types: SET [0:?] OF document_representation_type FOR represented_document;
+END_ENTITY;
+
+
+ENTITY document_file
+	SUBTYPE OF (document, characterized_object);
+WHERE
+	WR1 : SELF\characterized_object.name = '';
+	WR2 : NOT EXISTS(SELF\characterized_object.description);
+	WR3 : SIZEOF( QUERY( drt <* SELF\document.representation_types |
+               drt.name IN ['digital','physical'])) = 1;
+END_ENTITY;
+
+
+ENTITY document_identifier
+	SUBTYPE OF (group);
+UNIQUE
+  UR1: SELF\group.name, SELF\group.description;
+END_ENTITY;
+
+
+ENTITY document_identifier_assignment
+	SUBTYPE OF (group_assignment);
+	items : SET [1:?] OF document_identifier_assigned_item;
+	SELF\group_assignment.assigned_group : document_identifier;
+END_ENTITY;
+
+
+ENTITY document_product_association;
+	name : label;
+	description : OPTIONAL text;
+	relating_document : document;
+	related_product : product_or_formation_or_definition;
+END_ENTITY;
+
+
+ENTITY document_product_equivalence
+	SUBTYPE OF (document_product_association);
+WHERE
+	WR1 : SELF\document_product_association.name = 'equivalence';
+	WR2 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT' IN TYPEOF(SELF\document_product_association.related_product)) OR ((SELF\document_product_association.relating_document.kind. product_data_type = 'configuration controlled document') AND (SIZEOF( QUERY( prpc <* USEDIN(SELF\document_product_association.related_product,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') | prpc.name = 'document' )) = 1));
+	WR3 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_FORMATION' IN TYPEOF(SELF.related_product)) OR ((SELF\document_product_association.relating_document.kind.product_data_type = 'configuration controlled document version') AND (SIZEOF( QUERY( prpc <* USEDIN(SELF.related_product\product_definition_formation.of_product, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') | prpc.name = 'document')) = 1));
+	WR4 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF(SELF.related_product)) OR ((SELF\document_product_association.relating_document.kind.product_data_type = 'configuration controlled document definition') AND (SIZEOF( QUERY( prpc <* USEDIN(SELF\document_product_association.related_product\product_definition.formation.of_product, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') | prpc.name = 'document' )) = 1));
+END_ENTITY;
+
+
+ENTITY document_reference
+	ABSTRACT SUPERTYPE;
+	assigned_document : document;
+	source : label;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY document_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_document : document;
+	related_document : document;
+END_ENTITY;
+
+
+ENTITY document_representation_type;
+	name : label;
+	represented_document : document;
+END_ENTITY;
+
+
+ENTITY document_type;
+	product_data_type : label;
+END_ENTITY;
+
+
+ENTITY document_usage_constraint;
+	source : document;
+	subject_element : label;
+	subject_element_value : text;
+END_ENTITY;
+
+
+ENTITY document_usage_constraint_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_document_usage : document_usage_constraint;
+	role : document_usage_role;
+END_ENTITY;
+
+
+ENTITY document_usage_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY dose_equivalent_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DOSE_EQUIVALENT_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY dose_equivalent_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.sievert);
+END_ENTITY;
+
+
+ENTITY double_offset_shelled_solid
+	SUBTYPE OF (shelled_solid);
+	thickness2 : length_measure;
+WHERE
+	WR1 : thickness2 <> 0;
+	WR2 : SELF\shelled_solid.thickness <> thickness2;
+END_ENTITY;
+
+
+ENTITY draped_defined_transformation
+	SUBTYPE OF (transformation_with_derived_angle);
+END_ENTITY;
+
+
+ENTITY draughting_annotation_occurrence
+	SUBTYPE OF (annotation_occurrence);
+WHERE
+	WR1 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_CURVE_OCCURRENCE'
+            IN TYPEOF (SELF))) OR
+    (SIZEOF (QUERY (sty <* SELF.styles |
+       NOT ((SIZEOF (sty.styles) = 1)
+         AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+                 IN TYPEOF (sty.styles[1]))) )) = 0);
+	WR2 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_FILL_AREA_OCCURRENCE'
+            IN TYPEOF (SELF))) OR    (SIZEOF (QUERY (sty <* SELF.styles |
+      NOT ((SIZEOF (sty.styles) = 1)
+        AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FILL_AREA_STYLE'
+                IN TYPEOF (sty.styles[1]))) )) = 0);
+	WR3 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_FILL_AREA_OCCURRENCE'
+            IN TYPEOF (SELF))) OR    (SIZEOF (QUERY (bound <*
+                     SELF.item\annotation_fill_area.boundaries |
+       NOT (SIZEOF (QUERY (si <*
+                   USEDIN (bound, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                  'STYLED_ITEM.ITEM') |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+             'ANNOTATION_CURVE_OCCURRENCE' IN TYPEOF (si)))) > 0))) = 0);
+	WR4 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL_OCCURRENCE'
+            IN TYPEOF (SELF))) OR    (SIZEOF (QUERY (sty <* SELF.styles |
+       NOT ((SIZEOF (sty.styles) = 1)           AND
+            (SIZEOF (TYPEOF (sty.styles[1]) *
+                ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SYMBOL_STYLE',
+                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NULL_STYLE']) = 1)) )) = 0);
+	WR5 : (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL_OCCURRENCE'
+             IN TYPEOF (SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL'
+             IN TYPEOF(SELF.item)))) OR
+         (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                   'DRAUGHTING_SYMBOL_REPRESENTATION',
+                  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                  'DRAUGHTING_SUBFIGURE_REPRESENTATION'] *
+          TYPEOF (SELF.item\mapped_item.mapping_source.
+                  mapped_representation)) = 1);
+	WR6 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+            IN TYPEOF (SELF))) OR
+    (SIZEOF (QUERY (sty <* SELF.styles |
+       NOT ((SIZEOF (sty.styles) = 1)
+        AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_STYLE'
+                IN TYPEOF (sty.styles[1]))) )) = 0);
+	WR7 : (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (SELF))) OR
+         (SIZEOF (TYPEOF(SELF.item) *
+             ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL']) = 1);
+	WR8 : (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'
+             IN TYPEOF (SELF.item)))) OR    (SIZEOF (QUERY (tl <*
+                   SELF.item\composite_text.collected_text |
+             NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL' 
+             IN TYPEOF (tl)) )) = 0);
+	WR9 : (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL'
+             IN TYPEOF (SELF.item)))) OR (SELF.item\text_literal.alignment 
+             IN ['baseline left', 'baseline centre', 'baseline right']);
+	WR10 : (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'
+             IN TYPEOF (SELF.item)))) OR
+         (SIZEOF (QUERY (tl <* QUERY (text <* SELF.
+                  item\composite_text.collected_text
+             |('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL' IN TYPEOF(text))) |
+          NOT (tl\text_literal.alignment IN
+         ['baseline left', 'baseline centre', 'baseline right']) )) = 0);
+	WR11 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF(SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'
+             IN TYPEOF (SELF.item))) OR check_text_alignment(SELF.item);
+	WR12 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF(SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'
+             IN TYPEOF (SELF.item))) OR check_text_font(SELF.item);
+	WR13 : (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF(SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'
+               IN TYPEOF (SELF.item)))) OR
+         (SIZEOF (QUERY (tl <* QUERY (text <*
+            SELF.item\composite_text.collected_text |
+            ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL' IN TYPEOF (text))) |
+             NOT (SIZEOF (TYPEOF(tl) *
+                  ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                   'TEXT_LITERAL_WITH_BLANKING_BOX',
+                   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                   'TEXT_LITERAL_WITH_ASSOCIATED_CURVES']) = 0) )) = 0);
+	WR14 : (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL_WITH_ASSOCIATED_CURVES'
+             IN TYPEOF (SELF.item)))) OR
+    (SIZEOF (QUERY (crv <*
+                   SELF.item\text_literal_with_associated_curves.
+                   associated_curves |
+      NOT (SIZEOF (QUERY (si <*  USEDIN (crv, 
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM.ITEM') |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_CURVE_OCCURRENCE'
+            IN TYPEOF (si)) )) > 0) )) = 0);
+	WR15 : (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT_WITH_ASSOCIATED_CURVES'
+             IN TYPEOF (SELF.item)))) OR
+          (SIZEOF (QUERY (crv <*
+                SELF.item\composite_text_with_associated_curves.
+                associated_curves |
+           NOT (SIZEOF (QUERY (si <*  USEDIN (crv,
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM.ITEM') |
+               ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_CURVE_OCCURRENCE'
+           IN TYPEOF (si)) )) > 0) )) = 0);
+	WR16 : SIZEOF (QUERY (cs <* QUERY (sty <* SELF.styles |
+      ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE' IN TYPEOF (sty.styles[1])))
+      | NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE_WITH_UNIT'
+        IN TYPEOF (cs.styles[1]\curve_style.curve_width)) AND
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE'
+        IN TYPEOF (cs.styles[1]\curve_style.
+        curve_width\measure_with_unit.value_component))))) = 0;
+	WR17 : SIZEOF (QUERY (fas <* QUERY (sty <* SELF.styles |
+      ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FILL_AREA_STYLE'
+          IN TYPEOF (sty.styles[1]))) |
+      NOT ((SIZEOF (QUERY (fs <* fas.styles[1]\fill_area_style.fill_styles
+                    | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FILL_AREA_STYLE_TILES'
+                       IN TYPEOF (fs)))) <= 1)
+       AND (SIZEOF (QUERY (fst <* QUERY (fs <*
+                           fas.styles[1]\fill_area_style.fill_styles |
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FILL_AREA_STYLE_TILES'
+                  IN TYPEOF (fs))) |
+                 NOT (SIZEOF (fst\fill_area_style_tiles.tiles) = 1)
+           )) = 0))
+    )) = 0;
+	WR18 : SIZEOF (QUERY (fas <* QUERY (sty <* SELF.styles |
+           ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FILL_AREA_STYLE' 
+            IN TYPEOF (sty.styles[1]))) |
+             NOT (SIZEOF (QUERY (fsh <* QUERY (fs <*
+                          fas.styles[1]\fill_area_style.fill_styles |
+             ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FILL_AREA_STYLE_HATCHING'
+               IN TYPEOF (fs))) |
+        NOT (fsh\fill_area_style_hatching.point_of_reference_hatch_line :=:
+             fsh\fill_area_style_hatching.pattern_start)  )) = 0)  )) = 0;
+	WR19 : SIZEOF (QUERY (ts <* QUERY (sty <* SELF.styles |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_STYLE' 
+         IN TYPEOF(sty.styles[1]))) |
+             NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                  'TEXT_STYLE_WITH_BOX_CHARACTERISTICS'
+             IN TYPEOF (ts.styles[1])))) = 0;
+	WR20 : SIZEOF (QUERY (ts <* QUERY (sty <* SELF.styles |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_STYLE_WITH_BOX_CHARACTERISTICS'
+             IN TYPEOF (sty.styles[1]))) |
+           NOT (SIZEOF (ts.styles[1]\text_style_with_box_characteristics.
+                characteristics) = 4) )) = 0;
+END_ENTITY;
+
+
+ENTITY draughting_callout
+	SUPERTYPE OF ((ONEOF (datum_feature_callout, datum_target_callout, dimension_curve_directed_callout, draughting_elements, geometrical_tolerance_callout, leader_directed_callout, projection_directed_callout, structured_dimension_callout) ANDOR surface_condition_callout))
+	SUBTYPE OF (geometric_representation_item);
+	contents : SET [1:?] OF draughting_callout_element;
+WHERE
+	WR1 : (SIZEOF (QUERY (l_1 <* SELF\draughting_callout.contents |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_CURVE' IN (TYPEOF(l_1)))) = 0) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_DIRECTED_CALLOUT' IN (TYPEOF(SELF))) AND
+        (SIZEOF (QUERY (l_1 <* SELF\draughting_callout.contents |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_CURVE' IN (TYPEOF(l_1)))) = 0) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_DIRECTED_CALLOUT' IN (TYPEOF(SELF))) AND  
+        (SIZEOF (QUERY (l_1 <* SELF\draughting_callout.contents |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE' IN (TYPEOF(l_1)))) = 0) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE_DIRECTED_CALLOUT' IN (TYPEOF(SELF)));
+END_ENTITY;
+
+
+ENTITY draughting_callout_relationship;
+	name : label;
+	description : text;
+	relating_draughting_callout : draughting_callout;
+	related_draughting_callout : draughting_callout;
+END_ENTITY;
+
+
+ENTITY draughting_elements
+	SUBTYPE OF (draughting_callout);
+WHERE
+	WR1 : SIZEOF (QUERY (l_c <* QUERY (con <* SELF.contents |
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_CURVE' IN TYPEOF(con))) |
+              NOT (SIZEOF (QUERY (ldc <* USEDIN (l_c,
+               'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DRAUGHTING_CALLOUT.CONTENTS') |
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_DIRECTED_CALLOUT'
+              IN TYPEOF (ldc)))) <= 1)))=0;
+	WR2 : NOT    ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE_DIRECTED_CALLOUT'
+              IN TYPEOF(SELF)) OR
+              (SIZEOF (QUERY (con <* SELF.contents |
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_CURVE' IN
+               TYPEOF (con)))) <= 2);
+	WR3 : SIZEOF (QUERY (rc <* USEDIN (SELF,
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT_' +
+              'RELATIONSHIP.RELATING_DRAUGHTING_CALLOUT') |
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+               'DIMENSION_CALLOUT_RELATIONSHIP' IN TYPEOF (rc)) AND
+              (rc.name = 'primary') )) <= 1;
+	WR4 : SIZEOF (QUERY (rc <* USEDIN (SELF,
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT_' +
+              'RELATIONSHIP.RELATING_DRAUGHTING_CALLOUT') |
+               ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                'DIMENSION_CALLOUT_RELATIONSHIP' IN TYPEOF (rc)) AND
+                (rc.name = 'secondary') )) <= 1;
+	WR5 : SIZEOF (QUERY (sec <* QUERY (rc <* USEDIN (SELF,
+               'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT_' +
+               'RELATIONSHIP.RELATING_DRAUGHTING_CALLOUT') |
+               ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                'DIMENSION_CALLOUT_RELATIONSHIP' IN TYPEOF (rc)) AND         
+                (rc.name = 'secondary') ) |
+         NOT (SIZEOF (QUERY (prim <* USEDIN (SELF,
+               'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT_' +
+               'RELATIONSHIP.RELATING_DRAUGHTING_CALLOUT') |
+               ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                'DIMENSION_CALLOUT_RELATIONSHIP' IN TYPEOF (prim)) AND         
+                (prim.name = 'primary') )) = 1))) = 0;
+END_ENTITY;
+
+
+ENTITY draughting_model
+	SUBTYPE OF (representation);
+	SELF\representation.items : SET [1:?] OF draughting_model_item_select;
+UNIQUE
+  UR1: SELF\representation.name;
+WHERE
+	WR1 : SIZEOF (QUERY (mi <* QUERY (it <* SELF.items |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF(it))) |
+         NOT (
+           SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION',
+                    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_MODEL'] *
+              TYPEOF (mi\mapped_item.mapping_source.
+                      mapped_representation)) = 1
+        ))) = 0;
+	WR2 : SIZEOF (QUERY (smi <* QUERY (si <* QUERY (it <* SELF.items |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM' IN TYPEOF(it))) |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN
+            TYPEOF(si\styled_item.item))) |
+        (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION' IN
+                 TYPEOF(smi\styled_item.item\mapped_item.
+                        mapping_source.mapped_representation))
+            AND
+             (SIZEOF (QUERY (sty <* smi\styled_item.styles |
+               (NOT (SIZEOF (QUERY (psa <* sty.styles |
+                       (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE' IN TYPEOF(psa))))) = 1
+             )))) = 1)))
+        )) = 0;
+END_ENTITY;
+
+
+ENTITY draughting_model_item_association
+	SUBTYPE OF (item_identified_representation_usage);
+	SELF\item_identified_representation_usage.definition : shape_definition;
+	SELF\item_identified_representation_usage.identified_item : draughting_model_item_association_select;
+	SELF\item_identified_representation_usage.used_representation : draughting_model;
+END_ENTITY;
+
+
+ENTITY draughting_pre_defined_colour
+	SUBTYPE OF (pre_defined_colour);
+WHERE
+	WR1 : SELF.name IN
+      ['red',
+       'green',
+       'blue',
+       'yellow',
+       'magenta',
+       'cyan',
+       'black',
+       'white'];
+END_ENTITY;
+
+
+ENTITY draughting_pre_defined_curve_font
+	SUBTYPE OF (pre_defined_curve_font);
+WHERE
+	WR1 : SELF.name IN
+        ['continuous',
+         'chain',
+         'chain double dash',
+         'dashed',
+         'dotted'];
+END_ENTITY;
+
+
+ENTITY draughting_pre_defined_text_font
+	SUBTYPE OF (pre_defined_text_font);
+WHERE
+	WR1 : SELF.name[1:8] = 'ISO 3098';
+END_ENTITY;
+
+
+ENTITY draughting_subfigure_representation
+	SUBTYPE OF (symbol_representation);
+WHERE
+	WR1 : SIZEOF (QUERY (item <* SELF\representation.items |
+         NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_OCCURRENCE',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT']
+               * TYPEOF (item)) = 1))) = 0;
+	WR2 : SIZEOF (QUERY (item <* SELF\representation.items |
+         SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_OCCURRENCE',
+                  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT'] *
+           TYPEOF (item)) = 1)) >= 1;
+	WR3 : SIZEOF (QUERY (srm <* QUERY (rm <*
+          USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                        'REPRESENTATION_MAP.MAPPED_REPRESENTATION') |
+          ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SYMBOL_REPRESENTATION_MAP'
+             IN TYPEOF(rm))) | 
+            NOT (SIZEOF (QUERY (a_s <* QUERY (mi <* srm.map_usage |
+            ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL' IN TYPEOF(mi)))
+          | NOT (SIZEOF (QUERY (aso <*
+            USEDIN (a_s, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+                         'STYLED_ITEM.ITEM') |
+          NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SUBFIGURE_OCCURRENCE'
+            IN TYPEOF(aso)))) = 0))) = 0))) > 0;
+	WR4 : NOT (acyclic_mapped_item_usage (SELF));
+	WR5 : SIZEOF (SELF.context_of_items.representations_in_context) = 1;
+END_ENTITY;
+
+
+ENTITY draughting_symbol_representation
+	SUBTYPE OF (symbol_representation);
+UNIQUE
+  UR1: SELF\representation.name;
+WHERE
+	WR1 : SIZEOF (QUERY (item <* SELF\representation.items |
+         NOT (SIZEOF (TYPEOF (item) *
+            ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_CURVE_OCCURRENCE',
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL_OCCURRENCE',
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_FILL_AREA_OCCURRENCE',
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE',
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT']) = 1)
+       )) = 0;
+	WR2 : SIZEOF (QUERY (item <* SELF\representation.items |
+         (SIZEOF (TYPEOF (item) *
+            ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_CURVE_OCCURRENCE',
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL_OCCURRENCE',
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_FILL_AREA_OCCURRENCE',
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE']) = 1)
+       )) >= 1;
+	WR3 : SIZEOF (QUERY (item <* SELF\representation.items |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SUBFIGURE_OCCURRENCE'
+          IN TYPEOF (item))) = 0;
+	WR4 : SIZEOF (QUERY (srm <* QUERY (rm <*
+          USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                        'REPRESENTATION_MAP.MAPPED_REPRESENTATION') |
+          ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SYMBOL_REPRESENTATION_MAP'
+             IN TYPEOF(rm))) |
+         (SIZEOF (QUERY (a_s <* QUERY (mi <* srm.map_usage |
+           ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL' IN TYPEOF(mi))) |
+         NOT (SIZEOF (QUERY(aso <*
+             USEDIN(a_s, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                         'STYLED_ITEM.ITEM') |
+             NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL_OCCURRENCE'
+                  IN TYPEOF(aso))
+          )) = 0) )) = 0) )) > 0;
+	WR5 : NOT (acyclic_mapped_item_usage (SELF));
+	WR6 : SIZEOF (SELF.context_of_items.representations_in_context) = 1;
+END_ENTITY;
+
+
+ENTITY draughting_text_literal_with_delineation
+	SUBTYPE OF (text_literal_with_delineation);
+WHERE
+	WR1 : SELF.delineation IN ['underline', 'overline'];
+END_ENTITY;
+
+
+ENTITY draughting_title;
+	items : SET [1:?] OF draughting_titled_item;
+	language : label;
+	contents : text;
+END_ENTITY;
+
+
+ENTITY drawing_definition;
+	drawing_number : identifier;
+	drawing_type : OPTIONAL label;
+END_ENTITY;
+
+
+ENTITY drawing_revision
+	SUBTYPE OF (presentation_set);
+	revision_identifier : identifier;
+	drawing_identifier : drawing_definition;
+	intended_scale : OPTIONAL text;
+UNIQUE
+	UR1 : revision_identifier, drawing_identifier;
+END_ENTITY;
+
+
+ENTITY drawing_revision_sequence;
+	predecessor : drawing_revision;
+	successor : drawing_revision;
+WHERE
+	WR1 : predecessor :<>: successor;
+END_ENTITY;
+
+
+ENTITY drawing_sheet_revision
+	SUBTYPE OF (presentation_area);
+	revision_identifier : identifier;
+WHERE
+	WR1 : SIZEOF( QUERY(item <* SELF\representation.items |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN (TYPEOF(item)))
+       AND
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAWING_SHEET_REVISION' IN
+       (TYPEOF(item\mapped_item.mapping_source.mapped_representation)))))=0;
+END_ENTITY;
+
+
+ENTITY drawing_sheet_revision_sequence
+	SUBTYPE OF (representation_relationship);
+WHERE
+	WR1 : SELF\representation_relationship.rep_1 :<>:                            
+       SELF\representation_relationship.rep_2;
+	WR2 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAWING_SHEET_REVISION'
+       IN TYPEOF (SELF\representation_relationship.rep_1);
+	WR3 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAWING_SHEET_REVISION'
+       IN TYPEOF (SELF\representation_relationship.rep_2);
+END_ENTITY;
+
+
+ENTITY drawing_sheet_revision_usage
+	SUBTYPE OF (area_in_set);
+	sheet_number : identifier;
+UNIQUE
+  UR1: sheet_number, SELF\area_in_set.in_set;
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAWING_SHEET_REVISION' IN 
+                  TYPEOF(SELF\area_in_set.area)) 
+              AND
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAWING_REVISION' 
+               IN TYPEOF (SELF\area_in_set.in_set));
+END_ENTITY;
+
+
+ENTITY edge
+	SUPERTYPE OF (ONEOF (edge_curve, oriented_edge, subedge))
+	SUBTYPE OF (topological_representation_item);
+	edge_start : vertex;
+	edge_end : vertex;
+END_ENTITY;
+
+
+ENTITY edge_based_wireframe_model
+	SUBTYPE OF (geometric_representation_item);
+	ebwm_boundary : SET [1:?] OF connected_edge_set;
+END_ENTITY;
+
+
+ENTITY edge_based_wireframe_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF ( 
+QUERY ( it <* SELF.items| NOT ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_BASED_WIREFRAME_MODEL', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D' ] * TYPEOF (it)) = 1) )) = 0;
+	WR2 : SIZEOF ( 
+QUERY ( it <* SELF.items| ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_BASED_WIREFRAME_MODEL', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' ] * TYPEOF (it)) = 1) )) >= 1;
+	WR3 : SIZEOF ( 
+QUERY ( ebwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( eb <* ebwm\edge_based_wireframe_model.ebwm_boundary| NOT ( SIZEOF ( 
+QUERY ( edges <* eb.ces_edges| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN TYPEOF (edges)) )) = 0) )) = 0) )) = 0;
+	WR4 : SIZEOF ( 
+QUERY ( ebwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( eb <* ebwm\edge_based_wireframe_model.ebwm_boundary| NOT ( SIZEOF ( 
+QUERY ( pline_edges <* 
+QUERY ( edges <* eb.ces_edges| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF (edges\edge_curve.edge_geometry)) )| NOT ( SIZEOF (pline_edges\edge_curve.edge_geometry\polyline.points) > 2) )) = 0) )) = 0) )) = 0;
+	WR5 : SIZEOF ( 
+QUERY ( ebwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( eb <* ebwm\edge_based_wireframe_model.ebwm_boundary| NOT ( SIZEOF ( 
+QUERY ( edges <* eb.ces_edges| NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (edges.edge_start)) AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (edges.edge_end))) )) = 0) )) = 0) )) = 0;
+	WR6 : SIZEOF ( 
+QUERY ( ebwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( eb <* ebwm\edge_based_wireframe_model.ebwm_boundary| NOT ( SIZEOF ( 
+QUERY ( edges <* eb.ces_edges| NOT valid_wireframe_edge_curve(edges\edge_curve.edge_geometry) )) = 0) )) = 0) )) = 0;
+	WR7 : SIZEOF ( 
+QUERY ( ebwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( eb <* ebwm\edge_based_wireframe_model.ebwm_boundary| NOT ( SIZEOF ( 
+QUERY ( edges <* eb.ces_edges| NOT (valid_wireframe_vertex_point(edges.edge_start\vertex_point.vertex_geometry) AND valid_wireframe_vertex_point(edges.edge_end\vertex_point.vertex_geometry)) )) = 0) )) = 0) )) = 0;
+	WR8 : SIZEOF ( 
+QUERY ( mi <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'EDGE_BASED_WIREFRAME_SHAPE_REPRESENTATION' IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation)) )) = 0;
+	WR9 : SELF.context_of_items\geometric_representation_context.coordinate_space_dimension = 3;
+END_ENTITY;
+
+
+ENTITY edge_blended_solid
+	ABSTRACT SUPERTYPE OF ((track_blended_solid ANDOR ONEOF (solid_with_constant_radius_edge_blend, solid_with_variable_radius_edge_blend, solid_with_chamfered_edges)))
+	SUBTYPE OF (modified_solid);
+	blended_edges : LIST [1:?] OF  UNIQUE edge_curve;
+END_ENTITY;
+
+
+ENTITY edge_curve
+	SUBTYPE OF (edge, geometric_representation_item);
+	edge_geometry : curve;
+	same_sense : BOOLEAN;
+END_ENTITY;
+
+
+ENTITY edge_loop
+	SUBTYPE OF (loop, path);
+DERIVE
+	ne : INTEGER := SIZEOF(SELF\path.edge_list);
+WHERE
+	WR1 : (SELF\path.edge_list[1].edge_start) :=:
+        (SELF\path.edge_list[ne].edge_end);
+END_ENTITY;
+
+
+ENTITY effectivity
+	SUPERTYPE OF (ONEOF (serial_numbered_effectivity, dated_effectivity, lot_effectivity, time_interval_based_effectivity));
+	id : identifier;
+DERIVE
+	description : text := get_description_value(SELF);
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY effectivity_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_effectivity : effectivity;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY effectivity_context_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_effectivity_assignment : effectivity_assignment;
+	role : effectivity_context_role;
+END_ENTITY;
+
+
+ENTITY effectivity_context_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY effectivity_relationship;
+	name : label;
+	description : OPTIONAL text;
+	related_effectivity : effectivity;
+	relating_effectivity : effectivity;
+END_ENTITY;
+
+
+ENTITY electric_charge_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELECTRIC_CHARGE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY electric_charge_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.coulomb);
+END_ENTITY;
+
+
+ENTITY electric_current_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELECTRIC_CURRENT_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY electric_current_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 1.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY electric_potential_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELECTRIC_POTENTIAL_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY electric_potential_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.volt);
+END_ENTITY;
+
+
+ENTITY elementary_brep_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF (QUERY (it <* SELF.items |
+          NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACETED_BREP',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D'] *
+                   TYPEOF(it)) = 1))) = 0;
+	WR2 : SIZEOF (QUERY (it <* SELF.items |
+         SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP',
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'] * TYPEOF(it)) =1 )) > 0;
+	WR3 : SIZEOF (QUERY (msb <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+           NOT (SIZEOF (QUERY (csh <* msb_shells(msb) |
+            NOT (SIZEOF (QUERY(fcs <* csh.cfs_faces |
+              NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE' IN TYPEOF(fcs)))) = 0
+                 ))) = 0
+                   ))) = 0;
+	WR4 : SIZEOF (QUERY (msb <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+           NOT (SIZEOF (QUERY (csh <* msb_shells(msb) |
+            NOT (SIZEOF (QUERY(fcs <* csh\connected_face_set.cfs_faces |
+              NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELEMENTARY_SURFACE' IN
+                   TYPEOF(fcs\face_surface.face_geometry))
+             ))) = 0
+                 ))) = 0
+                   ))) = 0;
+	WR5 : SIZEOF (QUERY (msb <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+           NOT (SIZEOF (QUERY (csh <* msb_shells(msb) |
+             NOT (SIZEOF (QUERY(fcs <* csh\connected_face_set.cfs_faces |
+               NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+                  NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN
+            TYPEOF(oe.edge_element)))) = 0
+                   ))) = 0
+                 ))) = 0
+               ))) = 0
+             ))) = 0;
+	WR6 : SIZEOF (QUERY (msb <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+           NOT (SIZEOF (QUERY (csh <* msb_shells(msb) |
+             NOT (SIZEOF (QUERY(fcs <* csh\connected_face_set.cfs_faces |
+               NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                 NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+                   NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE'] *
+            TYPEOF(oe.edge_element\edge_curve.edge_geometry)) = 1 )
+               )) = 0
+               ))) = 0
+                 ))) = 0
+                   ))) = 0
+                    ))) = 0;
+	WR7 : SIZEOF (QUERY (msb <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+           NOT (SIZEOF (QUERY (csh <* msb_shells(msb) |
+             NOT (SIZEOF (QUERY(fcs <* csh\connected_face_set.cfs_faces |
+               NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                 NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+            NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF(oe.edge_start))
+                AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN
+                 TYPEOF(oe.edge_end))
+            ))) = 0
+              ))) = 0
+               ))) = 0
+                 ))) = 0
+                   ))) = 0;
+	WR8 : SIZEOF (QUERY (msb <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+           NOT (SIZEOF (QUERY (csh <* msb_shells(msb) |
+             NOT (SIZEOF (QUERY(fcs <* csh\connected_face_set.cfs_faces |
+               NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+                   ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN
+            TYPEOF(oe.edge_element\edge_curve.edge_geometry)) AND
+            (NOT (SIZEOF (oe\oriented_edge.edge_element\
+                  edge_curve.edge_geometry\polyline.points) >= 3))
+               )) = 0
+               ))) = 0
+                 ))) = 0
+                   ))) = 0
+                    ))) = 0;
+	WR9 : SIZEOF (QUERY (msb <* QUERY (it <* items |
+          'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+          'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_CLOSED_SHELL' IN TYPEOF
+              (msb\manifold_solid_brep.outer)))
+             = 0;
+	WR10 : SIZEOF (QUERY (brv <* QUERY (it <* items |
+          'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BREP_WITH_VOIDS' IN TYPEOF(it)) |
+          NOT (SIZEOF (QUERY (csh <* brv\brep_with_voids.voids |
+           csh\oriented_closed_shell.orientation)) = 0))) = 0;
+	WR11 : SIZEOF (QUERY (mi <*  QUERY (it <* items |
+                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF(it)) |
+          NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELEMENTARY_BREP_SHAPE_REPRESENTATION' IN
+             TYPEOF(mi\mapped_item.mapping_source.
+                           mapped_representation)))) = 0;
+	WR12 : SIZEOF (QUERY (msb <* QUERY (it <* SELF.items |
+            'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+            NOT (SIZEOF (QUERY (csh <* msb_shells(msb) |
+              NOT (SIZEOF (QUERY(fcs <* csh\connected_face_set.cfs_faces |
+               NOT (SIZEOF(QUERY (vlp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF(bnds.bound)) |
+           NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN
+               TYPEOF(vlp_fbnds\face_bound.bound\vertex_loop.loop_vertex)) AND
+                ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN
+                   TYPEOF(vlp_fbnds\face_bound.bound\vertex_loop.
+                     loop_vertex\vertex_point.vertex_geometry))
+            ))) = 0))) = 0))) = 0))) =0;
+END_ENTITY;
+
+
+ENTITY elementary_surface
+	SUPERTYPE OF (ONEOF (plane, cylindrical_surface, conical_surface, spherical_surface, toroidal_surface))
+	SUBTYPE OF (surface);
+	position : axis2_placement_3d;
+END_ENTITY;
+
+
+ENTITY ellipse
+	SUBTYPE OF (conic);
+	semi_axis_1 : positive_length_measure;
+	semi_axis_2 : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY energy_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ENERGY_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY energy_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.joule);
+END_ENTITY;
+
+
+ENTITY entity_assertion
+	SUBTYPE OF (fact_type);
+END_ENTITY;
+
+
+ENTITY enum_reference_prefix
+	SUBTYPE OF (descriptive_representation_item);
+END_ENTITY;
+
+
+ENTITY environment;
+	syntactic_representation : generic_variable;
+	semantics : variable_semantics;
+END_ENTITY;
+
+
+ENTITY evaluated_characteristic
+	SUBTYPE OF (representation, representation_relationship);
+UNIQUE
+  UR1: SELF\representation_relationship.rep_1, SELF\representation_relationship.rep_2;
+WHERE
+	WR1 : SELF\representation_relationship.rep_1 <> 
+       SELF\representation_relationship.rep_2;
+END_ENTITY;
+
+
+ENTITY evaluated_degenerate_pcurve
+	SUBTYPE OF (degenerate_pcurve);
+	equivalent_point : cartesian_point;
+END_ENTITY;
+
+
+ENTITY evaluation_product_definition
+	SUBTYPE OF (product_definition);
+END_ENTITY;
+
+
+ENTITY event_occurrence;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY event_occurrence_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_event_occurrence : event_occurrence;
+	role : event_occurrence_role;
+END_ENTITY;
+
+
+ENTITY event_occurrence_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_event : event_occurrence;
+	related_event : event_occurrence;
+END_ENTITY;
+
+
+ENTITY event_occurrence_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY exclusive_product_concept_feature_category
+	SUBTYPE OF (product_concept_feature_category);
+END_ENTITY;
+
+
+ENTITY executed_action
+	SUBTYPE OF (action);
+END_ENTITY;
+
+
+ENTITY expanded_uncertainty
+	SUBTYPE OF (standard_uncertainty);
+	coverage_factor : REAL;
+END_ENTITY;
+
+
+ENTITY explicit_procedural_geometric_representation_item_relationship
+	SUBTYPE OF (explicit_procedural_representation_item_relationship);
+	SELF\representation_item_relationship.related_representation_item : geometric_representation_item;
+	SELF\representation_item_relationship.relating_representation_item : procedural_shape_representation_sequence;
+WHERE
+	WR1 : NOT (
+    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROCEDURAL_SHAPE_REPRESENTATION_SEQUENCE'
+    IN TYPEOF(
+      SELF\representation_item_relationship.related_representation_item));
+END_ENTITY;
+
+
+ENTITY explicit_procedural_representation_item_relationship
+	SUBTYPE OF (representation_item_relationship);
+	SELF\representation_item_relationship.relating_representation_item : procedural_representation_sequence;
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROCEDURAL_REPRESENTATION_SEQUENCE'
+    IN TYPEOF(
+      SELF\representation_item_relationship.related_representation_item));
+	WR2 : SIZEOF(QUERY(q <* using_representations(
+    SELF\representation_item_relationship.related_representation_item) |
+    item_in_context(
+      SELF\representation_item_relationship.relating_representation_item,
+      q.context_of_items))) > 0;
+END_ENTITY;
+
+
+ENTITY explicit_procedural_representation_relationship
+	SUBTYPE OF (representation_relationship);
+	SELF\representation_relationship.rep_1 : procedural_representation;
+WHERE
+	WR1 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROCEDURAL_REPRESENTATION' 
+    IN TYPEOF(SELF\representation_relationship.rep_2))) AND 
+    (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VARIATIONAL_REPRESENTATION'
+    IN TYPEOF(SELF\representation_relationship.rep_2)));
+	WR2 : SELF\representation_relationship.rep_1.context_of_items :=:
+    SELF\representation_relationship.rep_2.context_of_items;
+END_ENTITY;
+
+
+ENTITY explicit_procedural_shape_representation_relationship
+	SUBTYPE OF (explicit_procedural_representation_relationship);
+	SELF\representation_relationship.rep_1 : procedural_shape_representation;
+	SELF\representation_relationship.rep_2 : shape_representation;
+END_ENTITY;
+
+
+ENTITY expression
+	ABSTRACT SUPERTYPE OF (ONEOF (numeric_expression, boolean_expression))
+	SUBTYPE OF (generic_expression);
+END_ENTITY;
+
+
+ENTITY expression_conversion_based_unit
+	SUBTYPE OF (context_dependent_unit, variable_semantics);
+INVERSE
+	associated_variable_environment: environment FOR semantics;
+END_ENTITY;
+
+
+ENTITY extension
+	SUBTYPE OF (derived_shape_aspect);
+WHERE
+	WR1 : SIZEOF (SELF\derived_shape_aspect.deriving_relationships)= 1;
+END_ENTITY;
+
+
+ENTITY extent
+	SUBTYPE OF (characterized_object);
+END_ENTITY;
+
+
+ENTITY external_class_library
+	SUBTYPE OF (external_source);
+END_ENTITY;
+
+
+ENTITY external_identification_assignment
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (identification_assignment);
+	source : external_source;
+END_ENTITY;
+
+
+ENTITY external_source;
+	source_id : source_item;
+DERIVE
+	description : text := get_description_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY external_source_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_source : external_source;
+	related_source : external_source;
+END_ENTITY;
+
+
+ENTITY externally_defined_class
+	SUBTYPE OF (class, externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_colour
+	SUBTYPE OF (colour_specification, externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_context_dependent_unit
+	SUBTYPE OF (context_dependent_unit, externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_conversion_based_unit
+	SUBTYPE OF (conversion_based_unit, externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_currency
+	SUBTYPE OF (currency, externally_defined_context_dependent_unit);
+END_ENTITY;
+
+
+ENTITY externally_defined_curve_font
+	SUBTYPE OF (externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_dimension_definition
+	SUBTYPE OF (dimensional_size, externally_defined_item);
+WHERE
+	WR1 : (SELF\externally_defined_item.item_id = 'external size dimension') AND (SELF\externally_defined_item.source.source_id = 'external size dimension specification');
+	WR2 : 1 >= SIZEOF(QUERY ( adr <* USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.APPLIED_DOCUMENT_REFERENCE.ITEMS')| (adr.assigned_document.description = 'external size dimension specification') ));
+END_ENTITY;
+
+
+ENTITY externally_defined_general_property
+	SUBTYPE OF (general_property, externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_hatch_style
+	SUBTYPE OF (externally_defined_item, geometric_representation_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_item;
+	item_id : source_item;
+	source : external_source;
+END_ENTITY;
+
+
+ENTITY externally_defined_item_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_item : externally_defined_item;
+	related_item : externally_defined_item;
+END_ENTITY;
+
+
+ENTITY externally_defined_marker
+	SUBTYPE OF (externally_defined_symbol, pre_defined_marker);
+END_ENTITY;
+
+
+ENTITY externally_defined_picture_representation_item
+	SUBTYPE OF (picture_representation_item);
+INVERSE
+	source: applied_external_identification_assignment FOR items;
+WHERE
+	WR1 : NOT (SELF\representation_item.name IN pre_defined_picture_representation_types);
+END_ENTITY;
+
+
+ENTITY externally_defined_representation_item
+	SUBTYPE OF (representation_item, externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_string
+	SUBTYPE OF (externally_defined_representation_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_symbol
+	SUBTYPE OF (externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_terminator_symbol
+	SUBTYPE OF (externally_defined_symbol);
+END_ENTITY;
+
+
+ENTITY externally_defined_text_font
+	SUBTYPE OF (externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_tile
+	SUBTYPE OF (externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_tile_style
+	SUBTYPE OF (externally_defined_item, geometric_representation_item);
+END_ENTITY;
+
+
+ENTITY extruded_area_solid
+	SUBTYPE OF (swept_area_solid);
+	extruded_direction : direction;
+	depth : positive_length_measure;
+WHERE
+	WR1 : dot_product(
+        (SELF\swept_area_solid.swept_area.basis_surface\
+        elementary_surface.position.p[3]), extruded_direction) <> 0.0;
+END_ENTITY;
+
+
+ENTITY extruded_face_solid
+	SUBTYPE OF (swept_face_solid);
+	extruded_direction : direction;
+	depth : positive_length_measure;
+WHERE
+	WR1 : dot_product(
+        (SELF\swept_face_solid.swept_face.face_geometry\
+        elementary_surface.position.p[3]), extruded_direction) <> 0.0;
+END_ENTITY;
+
+
+ENTITY extruded_face_solid_with_draft_angle
+	SUBTYPE OF (extruded_face_solid_with_trim_conditions);
+	draft_angle : plane_angle_measure;
+WHERE
+	WR1 : draft_angle <> 0;
+END_ENTITY;
+
+
+ENTITY extruded_face_solid_with_multiple_draft_angles
+	SUBTYPE OF (extruded_face_solid_with_trim_conditions);
+	drafted_edges : LIST [2:?] OF SET [1:?] OF edge_curve;
+	draft_angles : LIST [2:?] OF plane_angle_measure;
+WHERE
+	WR1 : SIZEOF(drafted_edges) = SIZEOF(draft_angles);
+	WR2 : SIZEOF(QUERY(q <* draft_angles | q = 0)) = 0;
+	WR3 : SIZEOF(QUERY(q <* drafted_edges | (SIZEOF(QUERY(r <* q | NOT 
+         (SELF\swept_face_solid.swept_face IN 
+          using_items(r,[])))) > 0))) = 0;
+END_ENTITY;
+
+
+ENTITY extruded_face_solid_with_trim_conditions
+	SUPERTYPE OF (ONEOF (extruded_face_solid_with_draft_angle, extruded_face_solid_with_multiple_draft_angles))
+	SUBTYPE OF (extruded_face_solid);
+	first_trim_condition : trim_condition_select;
+	second_trim_condition : trim_condition_select;
+	first_trim_intent : trim_intent;
+	second_trim_intent : trim_intent;
+	first_offset : non_negative_length_measure;
+	second_offset : non_negative_length_measure;
+WHERE
+	WR1 : NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE_ANGLE_MEASURE' 
+         IN TYPEOF(first_trim_condition)) OR
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE_ANGLE_MEASURE' 
+         IN TYPEOF(second_trim_condition)));
+	WR2 : NOT ((('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(first_trim_condition)) AND 
+         ((first_trim_intent = trim_intent.offset) 
+         OR (first_trim_intent = trim_intent.up_to_next))) OR  
+         (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(second_trim_condition)) AND 
+         ((second_trim_intent = trim_intent.offset) 
+         OR (second_trim_intent = trim_intent.up_to_next))));
+	WR3 : NOT (((NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(first_trim_condition))) AND 
+         ((first_trim_intent = trim_intent.blind) 
+         OR (first_trim_intent = trim_intent.through_all))) OR  
+         ((NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(second_trim_condition))) AND 
+         ((second_trim_intent = trim_intent.blind) 
+         OR (second_trim_intent = trim_intent.through_all))));
+	WR4 : (((first_trim_intent = trim_intent.offset) 
+           AND (first_offset > 0)) XOR
+         ((first_trim_intent <> trim_intent.offset) 
+           AND (first_offset = 0))) AND 
+         (((second_trim_intent = trim_intent.offset) 
+           AND (second_offset > 0)) XOR
+         ((second_trim_intent <> trim_intent.offset) 
+            AND (second_offset = 0)));
+	WR5 : NOT((('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(first_trim_condition)) AND
+            ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(second_trim_condition))) AND
+         (first_trim_condition = second_trim_condition));
+END_ENTITY;
+
+
+ENTITY face
+	SUPERTYPE OF (ONEOF (face_surface, subface, oriented_face))
+	SUBTYPE OF (topological_representation_item);
+	bounds : SET [1:?] OF face_bound;
+WHERE
+	WR1 : NOT (mixed_loop_type_set(list_to_set(list_face_loops(SELF))));
+	WR2 : SIZEOF(QUERY(temp <* bounds | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_OUTER_BOUND' IN
+                                               TYPEOF(temp))) <= 1;
+END_ENTITY;
+
+
+ENTITY face_based_surface_model
+	SUBTYPE OF (geometric_representation_item);
+	fbsm_faces : SET [1:?] OF connected_face_set;
+END_ENTITY;
+
+
+ENTITY face_bound
+	SUBTYPE OF (topological_representation_item);
+	bound : loop;
+	orientation : BOOLEAN;
+END_ENTITY;
+
+
+ENTITY face_outer_bound
+	SUBTYPE OF (face_bound);
+END_ENTITY;
+
+
+ENTITY face_surface
+	SUBTYPE OF (face, geometric_representation_item);
+	face_geometry : surface;
+	same_sense : BOOLEAN;
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_SURFACE' IN TYPEOF(face_geometry));
+END_ENTITY;
+
+
+ENTITY faceted_brep
+	SUBTYPE OF (manifold_solid_brep);
+END_ENTITY;
+
+
+ENTITY faceted_brep_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF ( 
+QUERY ( it <* items| NOT ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACETED_BREP', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D' ] * TYPEOF (it)) = 1) )) = 0;
+	WR2 : SIZEOF ( 
+QUERY ( it <* items| ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACETED_BREP', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' ] * TYPEOF (it)) = 1) )) > 0;
+	WR3 : SIZEOF ( 
+QUERY ( fbrep <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACETED_BREP' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( csh <* msb_shells(fbrep)| NOT ( SIZEOF ( 
+QUERY ( fcs <* csh\connected_face_set.cfs_faces| NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE' IN TYPEOF (fcs)) AND (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE' IN TYPEOF (fcs\face_surface.face_geometry)) AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF (fcs\face_surface.face_geometry\elementary_surface.position.location)))) )) = 0) )) = 0) )) = 0;
+	WR4 : SIZEOF ( 
+QUERY ( fbrep <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACETED_BREP' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( csh <* msb_shells(fbrep)| NOT ( SIZEOF ( 
+QUERY ( fcs <* csh\connected_face_set.cfs_faces| NOT ( SIZEOF ( 
+QUERY ( bnds <* fcs.bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_OUTER_BOUND' IN TYPEOF (bnds)) )) = 1) )) = 0) )) = 0) )) = 0;
+	WR5 : SIZEOF ( 
+QUERY ( msb <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF (it)) )| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_CLOSED_SHELL' IN TYPEOF (msb\manifold_solid_brep.outer)) )) = 0;
+	WR6 : SIZEOF ( 
+QUERY ( brv <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BREP_WITH_VOIDS' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( csh <* brv\brep_with_voids.voids| csh\oriented_closed_shell.orientation )) = 0) )) = 0;
+	WR7 : SIZEOF ( 
+QUERY ( mi <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACETED_BREP_SHAPE_REPRESENTATION' IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation)) )) = 0;
+END_ENTITY;
+
+
+ENTITY fact_type
+	SUBTYPE OF (property_definition);
+END_ENTITY;
+
+
+ENTITY fill_area_style
+	SUBTYPE OF (founded_item);
+	name : label;
+	fill_styles : SET [1:?] OF fill_style_select;
+WHERE
+	WR1 : SIZEOF(QUERY(fill_style <* SELF.fill_styles |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+         'FILL_AREA_STYLE_COLOUR' IN
+         TYPEOF(fill_style)
+         )) <= 1;
+END_ENTITY;
+
+
+ENTITY fill_area_style_colour;
+	name : label;
+	fill_colour : colour;
+END_ENTITY;
+
+
+ENTITY fill_area_style_hatching
+	SUBTYPE OF (geometric_representation_item);
+	hatch_line_appearance : curve_style;
+	start_of_next_hatch_line : one_direction_repeat_factor;
+	point_of_reference_hatch_line : cartesian_point;
+	pattern_start : cartesian_point;
+	hatch_line_angle : plane_angle_measure;
+END_ENTITY;
+
+
+ENTITY fill_area_style_tile_coloured_region
+	SUBTYPE OF (geometric_representation_item);
+	closed_curve : curve_or_annotation_curve_occurrence;
+	region_colour : colour;
+WHERE
+	WR1 : (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE' IN TYPEOF (closed_curve))) OR 
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCLE' IN TYPEOF (closed_curve)) OR 
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELLIPSE' IN TYPEOF (closed_curve)) OR 
+        ( ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' IN TYPEOF (closed_curve)) 
+             AND (closed_curve\b_spline_curve.closed_curve = TRUE) ) OR 
+        ( ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE' IN TYPEOF (closed_curve)) 
+             AND (closed_curve\composite_curve.closed_curve = TRUE) ) OR 
+        ( ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF (closed_curve)) 
+             AND (closed_curve\polyline.points[LOINDEX(closed_curve\polyline.points)] = 
+                  closed_curve\polyline.points[HIINDEX(closed_curve\polyline.points)]) );
+END_ENTITY;
+
+
+ENTITY fill_area_style_tile_curve_with_style
+	SUBTYPE OF (geometric_representation_item);
+	styled_curve : annotation_curve_occurrence;
+END_ENTITY;
+
+
+ENTITY fill_area_style_tile_symbol_with_style
+	SUBTYPE OF (geometric_representation_item);
+	symbol : annotation_symbol_occurrence;
+END_ENTITY;
+
+
+ENTITY fill_area_style_tiles
+	SUBTYPE OF (geometric_representation_item);
+	tiling_pattern : two_direction_repeat_factor;
+	tiles : SET [1:?] OF fill_area_style_tile_shape_select;
+	tiling_scale : positive_ratio_measure;
+END_ENTITY;
+
+
+ENTITY flat_pattern_ply_representation_relationship
+	SUBTYPE OF (shape_representation_relationship);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION' IN
+        (TYPEOF (SELF\representation_relationship.rep_1) *
+         TYPEOF (SELF\representation_relationship.rep_2));
+	WR2 : SELF\representation_relationship.rep_1.
+        context_of_items\geometric_representation_context.
+        coordinate_space_dimension = 3;
+END_ENTITY;
+
+
+ENTITY flatness_tolerance
+	SUBTYPE OF (geometric_tolerance);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE' IN TYPEOF (SELF));
+END_ENTITY;
+
+
+ENTITY force_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FORCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY force_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.newton);
+END_ENTITY;
+
+
+ENTITY forward_chaining_rule
+	SUBTYPE OF (rule_definition);
+END_ENTITY;
+
+
+ENTITY forward_chaining_rule_premise
+	SUBTYPE OF (property_definition, property_definition_representation, representation);
+END_ENTITY;
+
+
+ENTITY founded_item
+	SUPERTYPE OF (ONEOF (character_glyph_style_outline, character_glyph_style_stroke, curve_style, curve_style_font, curve_style_font_and_scaling, curve_style_font_pattern, fill_area_style, point_style, presentation_style_assignment, surface_side_style, surface_style_boundary, surface_style_control_grid, surface_style_fill_area, surface_style_parameter_line, surface_style_segmentation_curve, surface_style_silhouette, surface_style_usage, symbol_style, text_style));
+DERIVE
+	users : SET [0:?] OF founded_item_select := using_items(SELF,[]);
+WHERE
+	WR1 : SIZEOF(users) > 0;
+	WR2 : NOT(SELF IN users);
+END_ENTITY;
+
+
+ENTITY frequency_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FREQUENCY_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY frequency_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.hertz);
+END_ENTITY;
+
+
+ENTITY func
+	SUBTYPE OF (compound_representation_item);
+END_ENTITY;
+
+
+ENTITY functional_breakdown_context
+	SUBTYPE OF (breakdown_context);
+END_ENTITY;
+
+
+ENTITY functional_element_usage
+	SUBTYPE OF (breakdown_element_usage);
+END_ENTITY;
+
+
+ENTITY functionally_defined_transformation;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY general_material_property
+	SUBTYPE OF (general_property);
+WHERE
+	WR1 : SIZEOF( QUERY( gpa <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GENERAL_PROPERTY_ASSOCIATION.BASE_DEFINITION') | 
+        NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MATERIAL_PROPERTY' IN TYPEOF(gpa.derived_definition)) )) = 0;
+END_ENTITY;
+
+
+ENTITY general_property;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY general_property_association;
+	name : label;
+	description : OPTIONAL text;
+	base_definition : general_property;
+	derived_definition : derived_property_select;
+WHERE
+	WR1 : SIZEOF(USEDIN(derived_definition, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GENERAL_PROPERTY_ASSOCIATION.' + 'DERIVED_DEFINITION')) = 1;
+	WR2 : derived_definition.name = base_definition.name;
+END_ENTITY;
+
+
+ENTITY general_property_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_property : general_property;
+	related_property : general_property;
+END_ENTITY;
+
+
+ENTITY generic_character_glyph_symbol
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (symbol_representation);
+END_ENTITY;
+
+
+ENTITY generic_expression
+	ABSTRACT SUPERTYPE OF (ONEOF (simple_generic_expression, unary_generic_expression, binary_generic_expression, multiple_arity_generic_expression));
+WHERE
+	WR1 : is_acyclic(SELF);
+END_ENTITY;
+
+
+ENTITY generic_literal
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (simple_generic_expression);
+END_ENTITY;
+
+
+ENTITY generic_variable
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (simple_generic_expression);
+INVERSE
+	interpretation: environment FOR syntactic_representation;
+END_ENTITY;
+
+
+ENTITY geometric_alignment
+	SUBTYPE OF (derived_shape_aspect);
+WHERE
+	WR1 : SIZEOF (SELF\derived_shape_aspect.deriving_relationships)> 1;
+END_ENTITY;
+
+
+ENTITY geometric_curve_set
+	SUBTYPE OF (geometric_set);
+WHERE
+	WR1 : SIZEOF(QUERY(temp <* SELF\geometric_set.elements |
+                            'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE' IN TYPEOF(temp))) = 0;
+END_ENTITY;
+
+
+ENTITY geometric_intersection
+	SUBTYPE OF (derived_shape_aspect);
+WHERE
+	WR1 : SIZEOF (SELF\derived_shape_aspect.deriving_relationships)> 1;
+END_ENTITY;
+
+
+ENTITY geometric_item_specific_usage
+	SUBTYPE OF (item_identified_representation_usage);
+	SELF\item_identified_representation_usage.definition : geometric_item_specific_usage_select;
+	SELF\item_identified_representation_usage.identified_item : geometric_representation_item;
+	SELF\item_identified_representation_usage.used_representation : shape_representation;
+END_ENTITY;
+
+
+ENTITY geometric_model_element_relationship
+	SUBTYPE OF (geometric_representation_item, representation_item_relationship);
+	SELF\representation_item_relationship.related_representation_item : geometric_representation_item;
+	SELF\representation_item_relationship.relating_representation_item : geometric_representation_item;
+UNIQUE
+	UR1 : relating_representation_item, related_representation_item;
+WHERE
+	WR1 : SELF\representation_item_relationship.relating_representation_item :<>: 
+        SELF\representation_item_relationship.related_representation_item;
+END_ENTITY;
+
+
+ENTITY geometric_representation_context
+	SUBTYPE OF (representation_context);
+	coordinate_space_dimension : dimension_count;
+END_ENTITY;
+
+
+ENTITY geometric_representation_item
+	SUPERTYPE OF (ONEOF (point, direction, vector, placement, cartesian_transformation_operator, curve, surface, edge_curve, face_surface, poly_loop, vertex_point, solid_model, boolean_result, sphere, right_circular_cone, right_circular_cylinder, torus, block, right_angular_wedge, half_space_solid, shell_based_surface_model, face_based_surface_model, shell_based_wireframe_model, edge_based_wireframe_model, geometric_set, camera_model, camera_model_d3_multi_clipping_intersection, camera_model_d3_multi_clipping_union, light_source))
+	SUBTYPE OF (representation_item);
+DERIVE
+	dim : dimension_count := dimension_of(SELF);
+WHERE
+	WR1 : SIZEOF (QUERY (using_rep <* using_representations (SELF) |
+      NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_CONTEXT' IN
+      TYPEOF (using_rep.context_of_items)))) = 0;
+END_ENTITY;
+
+
+ENTITY geometric_set
+	SUBTYPE OF (geometric_representation_item);
+	elements : SET [1:?] OF geometric_set_select;
+END_ENTITY;
+
+
+ENTITY geometric_tolerance;
+	name : label;
+	description : text;
+	magnitude : measure_with_unit;
+	toleranced_shape_aspect : shape_aspect;
+WHERE
+	WR1 : ('NUMBER' IN TYPEOF
+       (magnitude\measure_with_unit.value_component)) AND
+       (magnitude\measure_with_unit.value_component >= 0.0);
+END_ENTITY;
+
+
+ENTITY geometric_tolerance_relationship;
+	name : label;
+	description : text;
+	relating_geometric_tolerance : geometric_tolerance;
+	related_geometric_tolerance : geometric_tolerance;
+END_ENTITY;
+
+
+ENTITY geometric_tolerance_with_datum_reference
+	SUBTYPE OF (geometric_tolerance);
+	datum_system : SET [1:?] OF datum_reference;
+END_ENTITY;
+
+
+ENTITY geometric_tolerance_with_defined_unit
+	SUBTYPE OF (geometric_tolerance);
+	unit_size : measure_with_unit;
+WHERE
+	WR1 : ('NUMBER' IN TYPEOF
+       (unit_size\measure_with_unit.value_component)) AND
+       (unit_size\measure_with_unit.value_component > 0.0);
+END_ENTITY;
+
+
+ENTITY geometrical_tolerance_callout
+	SUBTYPE OF (draughting_callout);
+END_ENTITY;
+
+
+ENTITY geometrically_bounded_2d_wireframe_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SELF.context_of_items\geometric_representation_context.
+            coordinate_space_dimension = 2;
+	WR2 : SIZEOF (QUERY (item <* SELF.items |
+         NOT (SIZEOF (TYPEOF (item) *
+['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET',          
+'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_2D',
+            'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM']) = 1)
+       )) = 0;
+	WR3 : SIZEOF (QUERY (item <* SELF.items |
+         SIZEOF (TYPEOF (item) *          
+['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET',
+            'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM']) = 1
+       )) >= 1;
+	WR4 : SIZEOF (QUERY (mi <* QUERY (item <* SELF.items |
+     ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+           IN TYPEOF (item))) |
+         NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+              'GEOMETRICALLY_BOUNDED_2D_WIREFRAME_REPRESENTATION'
+           IN TYPEOF
+              (mi\mapped_item.mapping_source.mapped_representation))
+       )) = 0;
+	WR5 : SIZEOF (QUERY (gcs <* QUERY (item <* SELF.items |
+     ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET'
+                IN TYPEOF (item))) |
+         NOT (SIZEOF (QUERY (elem <* gcs\geometric_set.elements |
+           NOT (SIZEOF (TYPEOF (elem) *
+             ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCLE',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELLIPSE',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_2D',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TRIMMED_CURVE']) =
+               1)
+         )) = 0)
+       )) = 0;
+	WR6 : SIZEOF (QUERY (gcs <* QUERY (item <* SELF.items |
+     ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET'
+                IN TYPEOF (item))) |
+         NOT (SIZEOF (QUERY (crv <* 
+           QUERY (elem <* gcs\geometric_set.elements |
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE'
+                   IN TYPEOF (elem))) |
+           NOT (valid_basis_curve_in_2d_wireframe
+              (crv))
+         )) = 0)
+       )) = 0;
+	WR7 : SIZEOF (QUERY (gcs <* QUERY (item <* SELF.items |         
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET'
+                IN TYPEOF (item))) |
+         NOT (SIZEOF (QUERY (pnt <*
+           QUERY (elem <* gcs\geometric_set.elements |
+             ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT'
+                  IN TYPEOF(elem))) |
+             NOT (SIZEOF (TYPEOF (pnt) *
+               ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE'])
+          = 1)
+         )) = 0)
+       )) = 0;
+END_ENTITY;
+
+
+ENTITY geometrically_bounded_surface_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF(QUERY(it <* SELF.items | NOT (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_SET', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D'] * TYPEOF(it)) = 1))) = 0;
+	WR2 : SIZEOF(QUERY(it <* SELF.items | SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_SET', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'] * TYPEOF(it)) = 1)) > 0;
+	WR3 : SIZEOF(QUERY(mi <* QUERY(it <* SELF.items | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF(it)) | NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION' IN TYPEOF(mi\mapped_item.mapping_source.mapped_representation)) AND (SIZEOF(QUERY(mr_it <* mi\mapped_item.mapping_source.mapped_representation.items | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_SET' IN TYPEOF(mr_it)))) > 0)))) = 0;
+	WR4 : SIZEOF(QUERY(gs <* QUERY(it <* SELF.items | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_SET' IN TYPEOF(it)) | NOT (SIZEOF(QUERY(pnt <* QUERY(gsel <* gs\geometric_set.elements | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT' IN TYPEOF(gsel)) | NOT (gbsf_check_point(pnt)))) = 0))) = 0;
+	WR5 : SIZEOF(QUERY(gs <* QUERY(it <* SELF.items | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_SET' IN TYPEOF(it)) | NOT (SIZEOF(QUERY(cv <* QUERY(gsel <* gs\geometric_set.elements | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE' IN TYPEOF(gsel)) | NOT (gbsf_check_curve(cv)))) = 0))) = 0;
+	WR6 : SIZEOF(QUERY(gs <* QUERY(it <* SELF.items | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_SET' IN TYPEOF(it)) | NOT (SIZEOF(QUERY(sf <* QUERY(gsel <* gs\geometric_set.elements | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE' IN TYPEOF(gsel)) | NOT (gbsf_check_surface(sf)))) = 0))) = 0;
+	WR7 : SIZEOF(QUERY(gs <* QUERY(it <* SELF.items | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_SET' IN TYPEOF(it)) | SIZEOF(QUERY(gsel <* gs\geometric_set.elements | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE' IN TYPEOF(gsel))) > 0)) > 0;
+END_ENTITY;
+
+
+ENTITY geometrically_bounded_wireframe_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF ( 
+QUERY ( it <* SELF.items| NOT ( SIZEOF ( TYPEOF (it) * [ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' ]) = 1) )) = 0;
+	WR2 : SIZEOF ( 
+QUERY ( it <* SELF.items| ( SIZEOF ( TYPEOF (it) * [ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' ]) = 1) )) >= 1;
+	WR3 : SIZEOF ( 
+QUERY ( gcs <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( crv <* 
+QUERY ( elem <* gcs\geometric_set.elements| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE' IN TYPEOF (elem)) )| NOT valid_geometrically_bounded_wf_curve(crv) )) = 0) )) = 0;
+	WR4 : SIZEOF ( 
+QUERY ( gcs <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( pnts <* 
+QUERY ( elem <* gcs\geometric_set.elements| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT' IN TYPEOF (elem)) )| NOT valid_geometrically_bounded_wf_point(pnts) )) = 0) )) = 0;
+	WR5 : SIZEOF ( 
+QUERY ( gcs <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( cnc <* 
+QUERY ( elem <* gcs\geometric_set.elements| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC' IN TYPEOF (elem)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D' IN TYPEOF (cnc\conic.position)) )) = 0) )) = 0;
+	WR6 : SIZEOF ( 
+QUERY ( gcs <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( pline <* 
+QUERY ( elem <* gcs\geometric_set.elements| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF (elem)) )| NOT ( SIZEOF (pline\polyline.points) > 2) )) = 0) )) = 0;
+	WR7 : SIZEOF ( 
+QUERY ( mi <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION' IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation)) )) = 0;
+END_ENTITY;
+
+
+ENTITY global_assignment
+	SUBTYPE OF (representation_item_relationship);
+END_ENTITY;
+
+
+ENTITY global_uncertainty_assigned_context
+	SUBTYPE OF (representation_context);
+	uncertainty : SET [1:?] OF uncertainty_measure_with_unit;
+END_ENTITY;
+
+
+ENTITY global_unit_assigned_context
+	SUBTYPE OF (representation_context);
+	units : SET [1:?] OF unit;
+END_ENTITY;
+
+
+ENTITY ground_fact
+	SUBTYPE OF (atomic_formula);
+END_ENTITY;
+
+
+ENTITY group;
+	name : label;
+	description : OPTIONAL text;
+DERIVE
+	id : identifier := get_id_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY group_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_group : group;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY group_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_group : group;
+	related_group : group;
+END_ENTITY;
+
+
+ENTITY half_space_solid
+	SUBTYPE OF (geometric_representation_item);
+	base_surface : surface;
+	agreement_flag : BOOLEAN;
+END_ENTITY;
+
+
+ENTITY hardness_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : ( {2<= SIZEOF ( SELF.items ) <=4} ) AND ( SIZEOF ( QUERY (
+        i <* items | ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF ( i ) ) AND (
+        i.name IN [ 'measuring method' , 'measuring position' ] ) )
+        ) + SIZEOF ( QUERY ( i <* items | ( SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MEASURE_REPRESENTATION_ITEM' ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'VALUE_RANGE']* TYPEOF ( i ) ) =1 )
+        AND ( i.name IN ['depth' , 'hardness'] ) ) ) = SIZEOF (
+        SELF.items ) );
+	WR2 : SIZEOF ( QUERY ( i <* SELF.items | i.name =
+        'measuring method' ) ) =1;
+	WR3 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='hardness' ) )
+        =1;
+	WR4 : SIZEOF ( QUERY ( i <* SELF.items | i.name =
+        'measuring position' ) ) <=1;
+	WR5 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='depth' ) )
+        <=1;
+	WR6 : ( SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) ) =1 ) AND ( SIZEOF ( QUERY ( pdr
+        <* USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) | SIZEOF ( QUERY ( gpa <* USEDIN (
+        pdr. definition ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'GENERAL_PROPERTY_ASSOCIATION.'+
+        'DERIVED_DEFINITION' ) | ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'GENERAL_PROPERTY' IN TYPEOF ( gpa. base_definition ) ) AND
+        ( gpa. base_definition.name ='surface_condition' ) ) ) =1 )
+        ) =1 );
+END_ENTITY;
+
+
+ENTITY hidden_element_over_riding_styled_item
+	SUBTYPE OF (context_dependent_over_riding_styled_item);
+	SELF\styled_item.item : camera_image;
+	SELF\context_dependent_over_riding_styled_item.style_context : LIST [1:1] OF presentation_view;
+INVERSE
+	container: SET [1:?] OF presentation_view FOR items;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CAMERA_MODEL_D3_WITH_HLHSR' IN TYPEOF
+                (SELF.item\mapped_item.mapping_source.mapping_origin);
+END_ENTITY;
+
+
+ENTITY hyperbola
+	SUBTYPE OF (conic);
+	semi_axis : positive_length_measure;
+	semi_imag_axis : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY id_attribute;
+	attribute_value : identifier;
+	identified_item : id_attribute_select;
+END_ENTITY;
+
+
+ENTITY identification_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_id : identifier;
+	role : identification_role;
+END_ENTITY;
+
+
+ENTITY identification_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY illuminance_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ILLUMINANCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY illuminance_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.lux);
+END_ENTITY;
+
+
+ENTITY included_text_block
+	SUBTYPE OF (mapped_item);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRUCTURED_TEXT_REPRESENTATION' IN TYPEOF(SELF\mapped_item.mapping_source.mapped_representation);
+END_ENTITY;
+
+
+ENTITY inclusion_product_concept_feature
+	SUBTYPE OF (conditional_concept_feature);
+WHERE
+	WR1 : NOT ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PACKAGE_PRODUCT_CONCEPT_FEATURE' IN TYPEOF ( SELF ) );
+	WR2 : SIZEOF (QUERY
+									( cfr <* USEDIN 
+											( SELF ,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONCEPT_FEATURE_RELATIONSHIP.RELATING_PRODUCT_CONCEPT_FEATURE' ) 
+											| 
+											'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'CONCEPT_FEATURE_RELATIONSHIP_WITH_CONDITION' IN TYPEOF( cfr ) 
+									) 
+								) + 
+				 SIZEOF(QUERY
+				 					( cfr <* USEDIN 
+				 							(SELF , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONCEPT_FEATURE_RELATIONSHIP.RELATED_PRODUCT_CONCEPT_FEATURE' ) 
+				 							| 
+											'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONCEPT_FEATURE_RELATIONSHIP_WITH_CONDITION' IN TYPEOF(cfr)
+									)
+								)= 0;
+	WR3 : SELF.condition.conditional_operator.name = 'implication';
+END_ENTITY;
+
+
+ENTITY indirectly_selected_elements
+	SUBTYPE OF (user_selected_elements);
+	indirectly_picked_items : SET [1:?] OF representation_item;
+END_ENTITY;
+
+
+ENTITY indirectly_selected_shape_elements
+	SUBTYPE OF (indirectly_selected_elements, user_selected_shape_elements);
+WHERE
+	WR1 : SIZEOF(QUERY(q <*
+    SELF\indirectly_selected_elements.indirectly_picked_items
+    | NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION_ITEM'
+    IN TYPEOF(q)))) = 0;
+END_ENTITY;
+
+
+ENTITY inductance_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INDUCTANCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY inductance_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.henry);
+END_ENTITY;
+
+
+ENTITY information_right
+	SUBTYPE OF (action_method);
+END_ENTITY;
+
+
+ENTITY information_usage_right
+	SUBTYPE OF (action_method);
+END_ENTITY;
+
+
+ENTITY instance_usage_context_assignment
+	SUBTYPE OF (product_definition_context);
+	items : SET [1:?] OF instance_usage_context_select;
+END_ENTITY;
+
+
+ENTITY instanced_feature
+	SUBTYPE OF (shape_aspect, shape_feature_definition);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN
+         TYPEOF(SELF\shape_aspect.of_shape.definition);
+	WR2 : SELF\shape_aspect.product_definitional;
+END_ENTITY;
+
+
+ENTITY int_literal
+	SUBTYPE OF (literal_number);
+	SELF\literal_number.the_value : INTEGER;
+END_ENTITY;
+
+
+ENTITY integer_representation_item
+	SUBTYPE OF (representation_item, int_literal);
+END_ENTITY;
+
+
+ENTITY intersection_curve
+	SUBTYPE OF (surface_curve);
+WHERE
+	WR1 : SIZEOF(SELF\surface_curve.associated_geometry) = 2;
+	WR2 : associated_surface(SELF\surface_curve.associated_geometry[1]) <>
+             associated_surface(SELF\surface_curve.associated_geometry[2]);
+END_ENTITY;
+
+
+ENTITY interval_expression
+	SUBTYPE OF (boolean_expression, multiple_arity_generic_expression);
+DERIVE
+	interval_high : generic_expression := SELF\multiple_arity_generic_expression.operands[3];
+	interval_item : generic_expression := SELF\multiple_arity_generic_expression.operands[2];
+	interval_low : generic_expression := SELF\multiple_arity_generic_expression.operands[1];
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EXPRESSION' 
+				IN TYPEOF(interval_low))
+		AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EXPRESSION' 
+				IN TYPEOF(interval_item) )
+		AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EXPRESSION' 
+				IN TYPEOF(interval_high));
+	WR2 : (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_EXPRESSION' 
+				IN TYPEOF (SELF.interval_low)) 
+			AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_EXPRESSION'  
+				IN TYPEOF (SELF.interval_high)) 
+			AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_EXPRESSION' 
+				IN TYPEOF (SELF.interval_item))) 
+		OR
+		(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_EXPRESSION' 
+				IN TYPEOF(SELF.interval_low)) 
+			AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NUMERIC_EXPRESSION' 
+				IN TYPEOF(SELF.interval_item)) 
+			AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NUMERIC_EXPRESSION' 
+				IN TYPEOF(SELF.interval_high)));
+END_ENTITY;
+
+
+ENTITY invisibility;
+	invisible_items : SET [1:?] OF invisible_item;
+END_ENTITY;
+
+
+ENTITY iso4217_currency
+	SUBTYPE OF (currency);
+END_ENTITY;
+
+
+ENTITY item_defined_transformation;
+	name : label;
+	description : OPTIONAL text;
+	transform_item_1 : representation_item;
+	transform_item_2 : representation_item;
+END_ENTITY;
+
+
+ENTITY item_identified_representation_usage;
+	name : label;
+	description : OPTIONAL text;
+	definition : represented_definition;
+	used_representation : representation;
+	identified_item : representation_item;
+WHERE
+	WR1 : SELF.used_representation IN using_representations(SELF.identified_item);
+END_ENTITY;
+
+
+ENTITY known_source
+	SUBTYPE OF (external_source, pre_defined_item);
+END_ENTITY;
+
+
+ENTITY laid_defined_transformation
+	SUBTYPE OF (transformation_with_derived_angle);
+END_ENTITY;
+
+
+ENTITY laminate_table
+	SUPERTYPE OF (ONEOF (part_laminate_table, zone_structural_makeup))
+	SUBTYPE OF (product_definition);
+END_ENTITY;
+
+
+ENTITY language
+	SUBTYPE OF (group);
+WHERE
+	WR1 : SELF\group.name <> '';
+END_ENTITY;
+
+
+ENTITY leader_curve
+	SUBTYPE OF (annotation_curve_occurrence);
+WHERE
+	WR1 : SIZEOF( 
+          QUERY(ldc <* USEDIN( SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                       'DRAUGHTING_CALLOUT.CONTENTS')
+                   |   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                       'LEADER_DIRECTED_CALLOUT'  IN TYPEOF(ldc))) >= 1;
+END_ENTITY;
+
+
+ENTITY leader_directed_callout
+	SUBTYPE OF (draughting_callout);
+WHERE
+	WR1 : SIZEOF (QUERY (l_1 <* SELF\draughting_callout.contents |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_CURVE' IN (TYPEOF(l_1)))) >= 1;
+	WR2 : SIZEOF(SELF\draughting_callout.contents) >=2;
+END_ENTITY;
+
+
+ENTITY leader_directed_dimension
+	SUBTYPE OF (leader_directed_callout);
+WHERE
+	WR1 : SIZEOF (QUERY (con <* SELF.contents |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_CURVE' IN TYPEOF (con)))=1;
+END_ENTITY;
+
+
+ENTITY leader_terminator
+	SUBTYPE OF (terminator_symbol);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_CURVE' IN TYPEOF
+        (SELF\terminator_symbol.annotated_curve);
+END_ENTITY;
+
+
+ENTITY length_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY length_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 1.0) AND 
+    (SELF\named_unit.dimensions.mass_exponent = 0.0) AND 
+    (SELF\named_unit.dimensions.time_exponent = 0.0) AND 
+    (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND 
+    (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND 
+    (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND 
+    (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY light_source
+	SUPERTYPE OF (ONEOF (light_source_ambient, light_source_directional, light_source_positional, light_source_spot))
+	SUBTYPE OF (geometric_representation_item);
+	light_colour : colour;
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                              'STYLED_ITEM.ITEM')) = 0;
+END_ENTITY;
+
+
+ENTITY light_source_ambient
+	SUBTYPE OF (light_source);
+END_ENTITY;
+
+
+ENTITY light_source_directional
+	SUBTYPE OF (light_source);
+	orientation : direction;
+END_ENTITY;
+
+
+ENTITY light_source_positional
+	SUBTYPE OF (light_source);
+	position : cartesian_point;
+	constant_attenuation : REAL;
+	distance_attenuation : REAL;
+END_ENTITY;
+
+
+ENTITY light_source_spot
+	SUBTYPE OF (light_source);
+	position : cartesian_point;
+	orientation : direction;
+	concentration_exponent : REAL;
+	constant_attenuation : REAL;
+	distance_attenuation : REAL;
+	spread_angle : positive_plane_angle_measure;
+END_ENTITY;
+
+
+ENTITY limits_and_fits;
+	form_variance : label;
+	zone_variance : label;
+	grade : label;
+	source : text;
+END_ENTITY;
+
+
+ENTITY line
+	SUBTYPE OF (curve);
+	pnt : cartesian_point;
+	dir : vector;
+WHERE
+	WR1 : dir.dim  = pnt.dim;
+END_ENTITY;
+
+
+ENTITY line_profile_tolerance
+	SUBTYPE OF (geometric_tolerance);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE' IN TYPEOF (SELF)) OR ( SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 3);
+	WR2 : SIZEOF ( 
+QUERY ( sar <* USEDIN (SELF\geometric_tolerance.toleranced_shape_aspect, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'SHAPE_ASPECT_RELATIONSHIP.RELATING_SHAPE_ASPECT')| (sar.name IN [ 'affected plane association', 'resulting intersection curve association' ]) )) = 1;
+END_ENTITY;
+
+
+ENTITY linear_dimension
+	SUBTYPE OF (dimension_curve_directed_callout);
+END_ENTITY;
+
+
+ENTITY literal_conjunction
+	SUBTYPE OF (simple_clause);
+END_ENTITY;
+
+
+ENTITY literal_disjunction
+	SUBTYPE OF (simple_clause);
+END_ENTITY;
+
+
+ENTITY literal_number
+	ABSTRACT SUPERTYPE OF (ONEOF (int_literal, real_literal))
+	SUBTYPE OF (simple_numeric_expression, generic_literal);
+	the_value : NUMBER;
+END_ENTITY;
+
+
+ENTITY local_time;
+	hour_component : hour_in_day;
+	minute_component : OPTIONAL minute_in_hour;
+	second_component : OPTIONAL second_in_minute;
+	zone : coordinated_universal_time_offset;
+WHERE
+	WR1 : valid_time (SELF);
+END_ENTITY;
+
+
+ENTITY logical_literal
+	SUBTYPE OF (generic_literal);
+	lit_value : LOGICAL;
+END_ENTITY;
+
+
+ENTITY logical_representation_item
+	SUBTYPE OF (representation_item, logical_literal);
+END_ENTITY;
+
+
+ENTITY loop
+	SUPERTYPE OF (ONEOF (vertex_loop, edge_loop, poly_loop))
+	SUBTYPE OF (topological_representation_item);
+END_ENTITY;
+
+
+ENTITY loss_tangent_measure_with_unit
+	SUBTYPE OF (ratio_measure_with_unit);
+END_ENTITY;
+
+
+ENTITY lot_effectivity
+	SUBTYPE OF (effectivity);
+	effectivity_lot_id : identifier;
+	effectivity_lot_size : measure_with_unit;
+END_ENTITY;
+
+
+ENTITY luminous_flux_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LUMINOUS_FLUX_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY luminous_flux_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.lumen);
+END_ENTITY;
+
+
+ENTITY luminous_intensity_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LUMINOUS_INTENSITY_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY luminous_intensity_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 1.0);
+END_ENTITY;
+
+
+ENTITY magnetic_flux_density_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAGNETIC_FLUX_DENSITY_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY magnetic_flux_density_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.tesla);
+END_ENTITY;
+
+
+ENTITY magnetic_flux_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAGNETIC_FLUX_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY magnetic_flux_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.weber);
+END_ENTITY;
+
+
+ENTITY make_from_usage_option
+	SUBTYPE OF (product_definition_usage);
+	ranking : INTEGER;
+	ranking_rationale : text;
+	quantity : measure_with_unit;
+WHERE
+	WR1 : (NOT ('NUMBER' IN TYPEOF(quantity.value_component)))
+       OR (quantity.value_component > 0);
+END_ENTITY;
+
+
+ENTITY manifold_solid_brep
+	SUBTYPE OF (solid_model);
+	outer : closed_shell;
+END_ENTITY;
+
+
+ENTITY manifold_subsurface_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF (QUERY (it <* SELF.items |
+          NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D'] *
+                   TYPEOF(it)) = 1))) = 0;
+	WR2 : SIZEOF (QUERY (it <* SELF.items |
+         SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET',
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'] * TYPEOF(it)) =1 )) > 0;
+	WR3 : SIZEOF (QUERY (mi <*  QUERY (it <* items |
+                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF(it)) |
+   NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SUBSURFACE_SHAPE_REPRESENTATION' IN
+             TYPEOF(mi\mapped_item.mapping_source.
+                           mapped_representation)))) = 0;
+	WR4 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+          NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OPEN_SHELL' IN TYPEOF(cfss)))) = 0;
+	WR5 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+          NOT( (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN
+                   TYPEOF(cfss\connected_face_sub_set.parent_face_set))AND
+           (SIZEOF(QUERY(fac <* cfss\connected_face_sub_set.parent_face_set\connected_face_set.cfs_faces | NOT
+                 advanced_face_properties(fac))) = 0)) OR
+            (SIZEOF(QUERY(fac <* cfss\connected_face_sub_set.parent_face_set\connected_face_set.cfs_faces | NOT
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF(fac)))) = 0)
+                    ))) = 0;
+	WR6 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+          ( SIZEOF (QUERY (fac <* cfss\connected_face_set.cfs_faces  | NOT
+              advanced_face_properties(fac))) = 0))) = 0;
+	WR7 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+          'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+             NOT (SIZEOF (QUERY(fcs <* cfss\connected_face_set.cfs_faces |
+               ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBFACE' IN TYPEOF(fcs)) AND
+            NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+                  NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN
+            TYPEOF(oe.edge_element)) OR
+           ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBEDGE' IN
+            TYPEOF(oe.edge_element)) ))) = 0
+                   ))) = 0
+                 ))) = 0
+             ))) = 0;
+	WR8 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+             NOT (SIZEOF (QUERY(fcs <* cfss\connected_face_set.cfs_faces |
+           ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBFACE' IN TYPEOF(fcs)) AND
+               NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                 NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+          NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF(oe.edge_start))
+                AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN
+                 TYPEOF(oe.edge_end))
+            ))) = 0
+              ))) = 0
+               ))) = 0
+                   ))) = 0;
+	WR9 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+             NOT (SIZEOF (QUERY(fcs <* cfss\connected_face_set.cfs_faces |
+              ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBFACE' IN TYPEOF(fcs)) AND
+              ( NOT (SIZEOF(QUERY  (bnds <* fcs.bounds |
+         NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP'] *
+                   TYPEOF(bnds.bound)) = 1 )
+                   )) = 0)
+                 ))) = 0
+             ))) = 0;
+	WR10 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+             NOT (SIZEOF (QUERY(fcs <* cfss\connected_face_set.cfs_faces |
+              ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBFACE' IN TYPEOF(fcs)) AND
+              ( NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                 NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+                   NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' ] *
+            TYPEOF(oe.edge_element\edge_curve.edge_geometry)) = 1 )
+               )) = 0
+               ))) = 0
+                 )))) = 0
+                    ))) = 0;
+	WR11 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+             NOT (SIZEOF (QUERY(fcs <* cfss\connected_face_set.cfs_faces |
+              ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBFACE' IN TYPEOF(fcs)) AND
+               (NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+                   ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN
+            TYPEOF(oe.edge_element\edge_curve.edge_geometry)) AND
+            (NOT ((SIZEOF (QUERY (sc_ag <*
+            oe.edge_element\edge_curve.edge_geometry\
+            surface_curve.associated_geometry |
+            NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN
+            TYPEOF(sc_ag)))) = 0)))
+               )) = 0
+               ))) = 0
+                   )))) = 0
+                    ))) = 0;
+	WR12 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+             NOT (SIZEOF (QUERY(fcs <* cfss\connected_face_set.cfs_faces |
+              ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBFACE' IN TYPEOF(fcs)) AND
+               (NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+                   ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN
+            TYPEOF(oe.edge_element\edge_curve.edge_geometry)) AND
+            (NOT (SIZEOF (oe\oriented_edge.edge_element\
+                  edge_curve.edge_geometry\polyline.points) >= 3))
+               )) = 0
+               ))) = 0
+                   )))) = 0
+                    ))) = 0;
+END_ENTITY;
+
+
+ENTITY manifold_surface_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF (QUERY (it <* SELF.items |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D'] * TYPEOF (it)) = 1))) = 0;
+	WR2 : SIZEOF (QUERY (it <* SELF.items |
+       SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'] * TYPEOF (it)) = 1)) > 0;
+	WR3 : SIZEOF (QUERY (mi <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SURFACE_SHAPE_REPRESENTATION'
+       IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation))
+       AND
+       (SIZEOF(QUERY (mr_it <*
+       mi\mapped_item.mapping_source.mapped_representation.items |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL'
+       IN TYPEOF (mr_it)))) > 0 )))) = 0;
+	WR4 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (sh <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OPEN_SHELL',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_CLOSED_SHELL',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CLOSED_SHELL']
+       * TYPEOF (sh)) = 1))) = 0))) = 0;
+	WR5 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE' IN TYPEOF (fa)) )) = 0)))
+       = 0))) = 0;
+	WR6 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (msf_surface_check(fa\face_surface.face_geometry))))) = 0))) 
+       = 0))) = 0;
+	WR7 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (bnds <* fa.bounds |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP']
+       * TYPEOF (bnds.bound)) = 1))) = 0)))) = 0))) = 0))) = 0;
+	WR8 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items|
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list |
+       NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN TYPEOF 
+       (oe.edge_element)))) = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR9 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe_cv <* QUERY (oe <* 
+       elp_fbnds\path.edge_list |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN TYPEOF (oe.edge_element)) |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE'] * 
+       TYPEOF (oe_cv.edge_element\edge_curve.edge_geometry)) 
+       = 1))) = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR10 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list |
+       NOT (msf_curve_check (oe.edge_element\edge_curve.edge_geometry)))) 
+       = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR11 : SIZEOF (QUERY(sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list|
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF
+       (oe.edge_element.edge_start))
+       AND
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN
+       TYPEOF (oe.edge_element.edge_end))))) 
+       = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR12 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list |
+       NOT ((SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEGENERATE_PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_SURFACE'] * TYPEOF
+       (oe.edge_element.edge_start\vertex_point.vertex_geometry)) = 1)
+       AND
+       (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEGENERATE_PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_SURFACE'] * TYPEOF
+       (oe.edge_element.edge_end\vertex_point.vertex_geometry)) = 1
+       )))) = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR13 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <* 
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (vlp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF
+       (vlp_fbnds\vertex_loop.loop_vertex)))) = 0)))) = 0))) 
+       = 0))) = 0;
+	WR14 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <* 
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (vlp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEGENERATE_PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_SURFACE'] * TYPEOF
+       (vlp_fbnds\vertex_loop.loop_vertex\vertex_point.vertex_geometry)) 
+       = 1))) = 0)))) = 0))) = 0))) = 0;
+END_ENTITY;
+
+
+ENTITY mapped_item
+	SUBTYPE OF (representation_item);
+	mapping_source : representation_map;
+	mapping_target : representation_item;
+WHERE
+	WR1 : acyclic_mapped_representation(SELF);
+END_ENTITY;
+
+
+ENTITY mass_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MASS_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY mass_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 1.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY material_designation;
+	name : label;
+	definitions : SET [1:?] OF characterized_definition;
+END_ENTITY;
+
+
+ENTITY material_designation_characterization;
+	name : label;
+	description : text;
+	designation : material_designation;
+	property : characterized_material_property;
+END_ENTITY;
+
+
+ENTITY material_property
+	SUBTYPE OF (property_definition);
+UNIQUE
+  UR1: SELF\property_definition.name, SELF\property_definition.definition;
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CHARACTERIZED_OBJECT' IN
+          TYPEOF(SELF\property_definition.definition)) OR
+       (SIZEOF(bag_to_set(USEDIN(SELF ,
+                     'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                     'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION')) -
+              QUERY(temp <* bag_to_set(USEDIN(SELF ,
+                       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                       'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION')) |
+                       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                      'MATERIAL_PROPERTY_REPRESENTATION' IN
+                      TYPEOF(temp)))) = 0);
+END_ENTITY;
+
+
+ENTITY material_property_representation
+	SUBTYPE OF (property_definition_representation);
+	dependent_environment : data_environment;
+END_ENTITY;
+
+
+ENTITY measure_qualification;
+	name : label;
+	description : text;
+	qualified_measure : measure_with_unit;
+	qualifiers : SET [1:?] OF value_qualifier;
+WHERE
+	WR1 : SIZEOF(QUERY(temp <* qualifiers |
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRECISION_QUALIFIER'
+             IN TYPEOF(temp))) < 2;
+	WR2 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION_ITEM'
+           IN TYPEOF(SELF\measure_qualification.qualified_measure));
+END_ENTITY;
+
+
+ENTITY measure_representation_item
+	SUBTYPE OF (representation_item, measure_with_unit);
+END_ENTITY;
+
+
+ENTITY measure_with_unit
+	SUPERTYPE OF (ONEOF (length_measure_with_unit, mass_measure_with_unit, time_measure_with_unit, electric_current_measure_with_unit, thermodynamic_temperature_measure_with_unit, celsius_temperature_measure_with_unit, amount_of_substance_measure_with_unit, luminous_intensity_measure_with_unit, plane_angle_measure_with_unit, solid_angle_measure_with_unit, area_measure_with_unit, volume_measure_with_unit, ratio_measure_with_unit, acceleration_measure_with_unit, capacitance_measure_with_unit, electric_charge_measure_with_unit, conductance_measure_with_unit, electric_potential_measure_with_unit, energy_measure_with_unit, magnetic_flux_density_measure_with_unit, force_measure_with_unit, frequency_measure_with_unit, illuminance_measure_with_unit, inductance_measure_with_unit, luminous_flux_measure_with_unit, magnetic_flux_measure_with_unit, power_measure_with_unit, pressure_measure_with_unit, resistance_measure_with_unit, velocity_measure_with_unit, absorbed_dose_measure_with_unit, radioactivity_measure_with_unit, dose_equivalent_measure_with_unit));
+	value_component : measure_value;
+	unit_component : unit;
+WHERE
+	WR1 : valid_units(SELF);
+END_ENTITY;
+
+
+ENTITY mechanical_context
+	SUBTYPE OF (product_context);
+WHERE
+	WR1 : SELF.discipline_type = 'mechanical';
+END_ENTITY;
+
+
+ENTITY mechanical_design_and_draughting_relationship
+	SUBTYPE OF (definitional_representation_relationship_with_same_context);
+	SELF\representation_relationship.rep_1 : mechanical_design_and_draughting_relationship_select;
+	SELF\representation_relationship.rep_2 : mechanical_design_and_draughting_relationship_select;
+WHERE
+	WR1 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'DRAUGHTING_MODEL' IN TYPEOF(rep_2)) OR 
+       (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'DRAUGHTING_MODEL' IN TYPEOF(rep_1)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'SHAPE_REPRESENTATION' IN TYPEOF(rep_1)));
+	WR2 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION' IN TYPEOF(rep_2)) OR 
+       (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION' IN TYPEOF(rep_1)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'SHAPE_REPRESENTATION' IN TYPEOF(rep_1)));
+	WR3 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION' IN TYPEOF(rep_2)) OR 
+       (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION' IN TYPEOF(rep_1)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'SHAPE_REPRESENTATION' IN TYPEOF(rep_1)));
+END_ENTITY;
+
+
+ENTITY mechanical_design_geometric_presentation_area
+	SUBTYPE OF (presentation_area);
+	SELF\representation.items : SET [1:?] OF mechanical_design_geometric_presentation_area_items;
+WHERE
+	WR1 : SIZEOF(QUERY(it1 <* SELF.items |
+        NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(it1))
+        OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_VIEW'
+        IN TYPEOF
+        (it1\mapped_item.mapping_source.mapped_representation)))) = 0;
+	WR2 : SIZEOF(QUERY(pv <* QUERY(mi1 <* QUERY(it1 <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(it1)) |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_VIEW'
+        IN TYPEOF
+        (mi1\mapped_item.mapping_source.mapped_representation)) |
+        -- search in all presentation_views for axis2_placements and
+        -- mapped_items and for the subtype of mapped_item
+        -- camera_image_3d_with_scale; the latter shall reference
+        -- a mechanical_design_geometric_presentation_representation;
+        -- the supertype mapped_item shall reference presentation_view.
+        NOT (SIZEOF(QUERY(it2 <* pv\mapped_item.mapping_source.
+        mapped_representation\representation.items |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT'
+        IN TYPEOF(it2))
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(it2)) AND NOT
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'CAMERA_IMAGE_3D_WITH_SCALE' IN TYPEOF(it2))) AND NOT (
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_VIEW'
+        IN TYPEOF
+        (it2\mapped_item.mapping_source.mapped_representation)))
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'CAMERA_IMAGE_3D_WITH_SCALE' IN TYPEOF(it2))
+        AND NOT (
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION'
+        IN TYPEOF (it2\mapped_item.mapping_source.mapped_representation) ))
+        ))) = 0))) = 0;
+	WR3 : (SIZEOF(QUERY(ps <* USEDIN (SELF,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SIZE.UNIT') | ((ps.size\planar_extent.size_in_x <= 0)
+        OR
+        (ps.size\planar_extent.size_in_y <= 0)))) = 0)
+        AND
+        (SIZEOF(QUERY(ais <* USEDIN (SELF,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AREA_IN_SET.AREA') |
+        (SIZEOF(QUERY(ps <* USEDIN (ais, 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SIZE.UNIT') |
+        ((ps.size\planar_extent.size_in_x <= 0)
+        OR
+        (ps.size\planar_extent.size_in_y <= 0)))) > 0))) = 0);
+	WR4 : (SIZEOF(QUERY(ps <* USEDIN (SELF,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SIZE.UNIT') | 
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AXIS2_PLACEMENT_2D' IN TYPEOF (ps.size.placement)))) = 1)
+        AND
+        (SIZEOF(QUERY(ps <* USEDIN (SELF,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SIZE.UNIT') | 
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AXIS2_PLACEMENT_3D' IN TYPEOF (ps.size.placement)))) = 0)
+        OR
+        ((SIZEOF(QUERY(ais <* USEDIN (SELF,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AREA_IN_SET.AREA') |
+        (SIZEOF(QUERY(ps <* USEDIN (ais, 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SIZE.UNIT') |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AXIS2_PLACEMENT_2D' IN TYPEOF (ps.size.placement)))) = 1))) = 1)
+        AND
+        (SIZEOF(QUERY(ais <* USEDIN (SELF,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AREA_IN_SET.AREA') |
+        (SIZEOF(QUERY(ps <* USEDIN (ais, 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SIZE.UNIT') |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AXIS2_PLACEMENT_3D' IN TYPEOF (ps.size.placement)))) = 0))) = 1));
+END_ENTITY;
+
+
+ENTITY mechanical_design_geometric_presentation_representation
+	SUBTYPE OF (representation);
+	SELF\representation.items : SET [1:?] OF mechanical_design_geometric_presentation_representation_items;
+WHERE
+	WR1 : SIZEOF(QUERY(mi <* QUERY(it <* SELF.items |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(it))) | NOT (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SHAPE_REPRESENTATION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION']
+        * TYPEOF(mi\mapped_item.mapping_source.mapped_representation))
+        = 1))) = 0;
+	WR2 : SIZEOF(QUERY(smi <* QUERY(si <* QUERY(it <* SELF.items |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it))) |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(si\styled_item.item))) | NOT (
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SHAPE_REPRESENTATION' IN TYPEOF (smi\styled_item.
+        item\mapped_item.mapping_source.mapped_representation))) )) = 0;
+	WR3 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(pss <* psa.styles | NOT (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_STYLE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE']
+        * TYPEOF(pss)) = 1))) = 0))) = 0))) = 0;
+	WR4 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) |
+        NOT (SIZEOF(QUERY(psbc <* QUERY(psa <* si\styled_item.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_STYLE_BY_CONTEXT' IN TYPEOF(psa)) | NOT (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'REPRESENTATION_ITEM',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION']
+        * TYPEOF(psbc\presentation_style_by_context.style_context))
+        = 1))) = 0))) = 0;
+	WR5 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ps <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_STYLE'
+        IN TYPEOF(pss)) | NOT
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'POSITIVE_LENGTH_MEASURE' IN TYPEOF (ps\point_style.marker_size))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_COLOUR']
+        * TYPEOF(ps\point_style.marker_colour))
+        = 1)))) = 0))) = 0))) = 0;
+	WR6 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(cs <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF(pss)) | NOT((SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_COLOUR']
+        * TYPEOF(cs\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'POSITIVE_LENGTH_MEASURE' IN TYPEOF (cs\curve_style.curve_width))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_FONT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT']
+        * TYPEOF(cs\curve_style.curve_font)) = 1)))) = 0))) = 0))) = 0;
+	WR7 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ssu <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF(pss)) |
+        NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_SIDE_STYLE' IN TYPEOF
+        (ssu\surface_style_usage.style)))) = 0))) = 0))) = 0;
+	WR8 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ssu <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF(pss)) | NOT (SIZEOF(QUERY(sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        NOT (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_PARAMETER_LINE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_CONTROL_GRID',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_SILHOUETTE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_SEGMENTATION_CURVE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_FILL_AREA',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_BOUNDARY']
+        * TYPEOF(sses)) = 1))) = 0))) = 0))) = 0))) = 0;
+	WR9 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ssu <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF(pss)) | NOT (SIZEOF(QUERY(sspl <* QUERY(sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_PARAMETER_LINE' IN TYPEOF(sses)) |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF
+        (sspl\surface_style_parameter_line.style_of_parameter_lines))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_COLOUR']
+        * TYPEOF(sspl\surface_style_parameter_line.
+        style_of_parameter_lines\curve_style.curve_colour)) = 1)
+        AND (
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (sspl\surface_style_parameter_line.
+        style_of_parameter_lines\curve_style.curve_width))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_FONT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT']
+        * TYPEOF(sspl\surface_style_parameter_line.
+        style_of_parameter_lines\curve_style.curve_font)) = 1))))
+        = 0))) = 0))) = 0))) = 0;
+	WR10 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ssu <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF(pss)) | NOT (SIZEOF(QUERY(sscg <* QUERY(sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_CONTROL_GRID' IN TYPEOF(sses)) |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF (sscg\surface_style_control_grid.style_of_control_grid))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_COLOUR']
+        * TYPEOF(sscg\surface_style_control_grid.
+        style_of_control_grid\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'POSITIVE_LENGTH_MEASURE' IN TYPEOF 
+        (sscg\surface_style_control_grid.
+        style_of_control_grid\curve_style.curve_width))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_FONT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT']
+        * TYPEOF(sscg\surface_style_control_grid.
+        style_of_control_grid\curve_style.curve_font)) = 1))))
+        = 0))) = 0))) = 0))) = 0;
+	WR11 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) |
+        NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ssu <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF(pss)) | NOT (SIZEOF(QUERY(sssh <* QUERY(sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_SILHOUETTE' IN TYPEOF(sses)) |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF (sssh\surface_style_silhouette.style_of_silhouette))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_COLOUR']
+        * TYPEOF(sssh\surface_style_silhouette.
+        style_of_silhouette\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (sssh\surface_style_silhouette.style_of_silhouette\curve_style.
+        curve_width))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_FONT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT']
+        * TYPEOF(sssh\surface_style_silhouette.
+        style_of_silhouette\curve_style.curve_font)) = 1))))
+        = 0))) = 0))) = 0))) = 0;
+	WR12 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ssu <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF(pss)) | NOT (SIZEOF(QUERY(sssc <* QUERY(sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_SEGMENTATION_CURVE' IN TYPEOF(sses)) |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF
+        (sssc\surface_style_segmentation_curve.style_of_segmentation_curve))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_COLOUR']
+        * TYPEOF(sssc\surface_style_segmentation_curve.
+        style_of_segmentation_curve\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (sssc\surface_style_segmentation_curve.
+        style_of_segmentation_curve\curve_style.curve_width))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_FONT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT']
+        * TYPEOF(sssc\surface_style_segmentation_curve.
+        style_of_segmentation_curve\curve_style.curve_font)) = 1))))
+        = 0))) = 0))) = 0))) = 0;
+	WR13 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ssu <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF(pss)) | NOT (SIZEOF(QUERY(ssbd <* QUERY(sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_BOUNDARY' IN TYPEOF(sses)) |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF (ssbd\surface_style_boundary.style_of_boundary))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_COLOUR']
+        * TYPEOF(ssbd\surface_style_boundary.
+        style_of_boundary\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'POSITIVE_LENGTH_MEASURE' IN TYPEOF (ssbd\surface_style_boundary.
+        style_of_boundary\curve_style.curve_width))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_FONT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT']
+        * TYPEOF(ssbd\surface_style_boundary.
+        style_of_boundary\curve_style.curve_font)) = 1)))) = 0)))
+        = 0))) = 0))) = 0;
+END_ENTITY;
+
+
+ENTITY mechanical_design_presentation_representation_with_draughting
+	SUBTYPE OF (representation);
+	SELF\representation.items : SET [1:?] OF camera_model_d3;
+END_ENTITY;
+
+
+ENTITY mechanical_design_shaded_presentation_area
+	SUBTYPE OF (presentation_area);
+WHERE
+	WR1 : SIZEOF (QUERY (it1 <* SELF.items |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT'
+        IN TYPEOF (it1))
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF (it1)) AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_VIEW'
+        IN TYPEOF
+        (it1\mapped_item.mapping_source.mapped_representation)))))) = 0;
+	WR2 : SIZEOF (QUERY (pv <* QUERY (mi1 <* QUERY (it1 <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF (it1)) |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_VIEW'
+        IN TYPEOF
+        (mi1\mapped_item.mapping_source.mapped_representation)) |
+        (* search in all presentation_views for axis2_placements and
+           mapped_items and for the subtype of mapped_item,
+           camera_image_3d_with_scale; the latter shall reference
+           a mechanical_design_geometric_presentation_representation;
+           the supertype mapped_item shall reference presentation_view. *)
+        NOT (SIZEOF(QUERY(it2 <* pv\mapped_item.mapping_source.
+        mapped_representation\representation.items |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT'
+        IN TYPEOF(it2))
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(it2)) AND NOT
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'CAMERA_IMAGE_3D_WITH_SCALE' IN TYPEOF(it2))) AND NOT (
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_VIEW'
+        IN TYPEOF
+        (it2\mapped_item.mapping_source.mapped_representation)))
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'CAMERA_IMAGE_3D_WITH_SCALE' IN TYPEOF(it2))
+        AND NOT (
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION'
+        IN TYPEOF (it2\mapped_item.mapping_source.mapped_representation) ))
+        ))) = 0))) = 0;
+	WR3 : (SIZEOF (QUERY(ps <* USEDIN (SELF, 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+        'PRESENTATION_SIZE.UNIT') |
+        NOT ((ps.size\planar_extent.size_in_x > 0) 
+        AND (ps.size\planar_extent.size_in_y > 0)) )) = 0)
+        AND
+        (* check secondly for presentation_set, via area_in_set *)
+        (SIZEOF (QUERY(pset <* QUERY(ais <* 
+        USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+        'AREA_IN_SET.AREA') 
+        | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SET' IN TYPEOF (ais.in_set)) |
+        (* after having collected all presentation_set, check their sizes *)
+        SIZEOF (QUERY(psize <* USEDIN(pset, 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+        'PRESENTATION_SIZE.UNIT')
+        | NOT ((psize.size\planar_extent.size_in_x > 0) 
+        AND (psize.size\planar_extent.size_in_y > 0)) )) = 0)) = 0);
+	WR4 : (SIZEOF(QUERY( psize <* USEDIN (SELF, 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+        'PRESENTATION_SIZE.UNIT') 
+        | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AXIS2_PLACEMENT_2D' 
+        IN TYPEOF (psize.size.placement))) = 1)
+        AND
+        (* check secondly for presentation_set, via area_in_set *)
+        (SIZEOF (QUERY(pset <* QUERY(ais <* 
+        USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AREA_IN_SET.AREA')
+        | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SET' IN TYPEOF (ais.in_set)) |
+        (* after having collected all presentation_set, check their 
+           dimension *)
+        SIZEOF (QUERY(psize <* USEDIN(pset, 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+        'PRESENTATION_SIZE.UNIT')
+        | NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+        'AXIS2_PLACEMENT_2D' 
+        IN TYPEOF (psize.size.placement)) )) = 0)) = 0);
+	WR5 : SIZEOF (QUERY (pv <* QUERY (mi1 <* QUERY (it1 <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' 
+        IN TYPEOF (it1)) |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_VIEW' 
+        IN TYPEOF 
+        (mi1\mapped_item.mapping_source.mapped_representation)) |
+        (* search in all presentation_views for 
+           mapped_items and for the subtype of mapped_item,
+           camera_image_3d_with_scale; the latter shall reference
+           a camera_usage that shall have as its mapping_origin either
+           camera_model_d3, camera_model_d3_with_hlhsr, or
+           camera_model_with_light_sources. *)
+        NOT (SIZEOF(QUERY(ci <* pv\mapped_item.mapping_source.
+        mapped_representation\representation.items |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+         'CAMERA_IMAGE_3D_WITH_SCALE' IN TYPEOF(ci))
+        AND
+        (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CAMERA_MODEL_D3',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CAMERA_MODEL_D3_WITH_HLHSR',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CAMERA_MODEL_WITH_LIGHT_SOURCES'] * TYPEOF
+        (ci\mapped_item.mapping_source.mapping_origin))
+        = 1))) = 0))) = 0;
+END_ENTITY;
+
+
+ENTITY mechanical_design_shaded_presentation_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : SIZEOF(QUERY(it <* SELF.items |
+        NOT (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CAMERA_MODEL_D3']
+        * TYPEOF(it)) = 1))) = 0;
+	WR2 : SIZEOF(QUERY(mi <* QUERY(it <* SELF.items |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(it))) | NOT (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SHAPE_REPRESENTATION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION']
+        * TYPEOF(mi\mapped_item.mapping_source.mapped_representation))
+        = 1))) = 0;
+	WR3 : SIZEOF(QUERY(smi <* QUERY(si <* QUERY(it <* SELF.items |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it))) |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(si\styled_item.item))) | NOT (
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SHAPE_REPRESENTATION' IN TYPEOF (smi\styled_item.
+        item\mapped_item.mapping_source.mapped_representation))) )) = 0;
+	WR4 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (pss <* psa.styles |
+        NOT (SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_STYLE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE']
+        *  TYPEOF (pss)) = 1))) = 0))) = 0))) = 0;
+	WR5 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psbc <* QUERY (psa <* si\styled_item.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'PRESENTATION_STYLE_BY_CONTEXT' IN TYPEOF (psa))  |
+        NOT (SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION_ITEM',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION']
+        * TYPEOF (psbc\presentation_style_by_context.style_context)) = 1)))
+        = 0))) = 0;
+	WR6 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ps <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_STYLE'
+        IN TYPEOF (pss)) |
+        NOT (
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MARKER_TYPE'
+        IN TYPEOF (ps\point_style.marker))
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (ps\point_style.marker_size))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (ps\point_style.marker_colour)) = 1)))) = 0))) = 0))) = 0;
+	WR7 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (cs <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF (pss)) |
+        NOT (
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (cs\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (cs\curve_style.curve_width))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CURVE_STYLE_FONT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT'] * TYPEOF
+        (cs\curve_style.curve_font)) = 1)))) = 0))) = 0))) = 0;
+	WR8 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_SIDE_STYLE'
+        IN TYPEOF (ssu\surface_style_usage.style)) )) = 0))) = 0 ))) = 0;
+	WR9 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        NOT (SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_PARAMETER_LINE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_CONTROL_GRID',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_SILHOUETTE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_SEGMENTATION_CURVE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_BOUNDARY',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_FILL_AREA',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_RENDERING'] * TYPEOF (sses)) = 1))) = 0))) = 0)))
+        = 0))) = 0;
+	WR10 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (ssfa <* QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_FILL_AREA'
+        IN TYPEOF (sses)) |
+        NOT (SIZEOF (QUERY (fss <*
+        ssfa\surface_style_fill_area.fill_area.fill_styles |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'FILL_AREA_STYLE_COLOUR' IN TYPEOF (fss))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (fss\fill_area_style_colour.fill_colour)) = 1)))) = 0))) = 0)))
+        = 0))) = 0))) = 0;
+	WR11 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (sspl <* QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_PARAMETER_LINE' IN TYPEOF (sses)) |
+        NOT ((
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE' IN TYPEOF
+        (sspl\surface_style_parameter_line.style_of_parameter_lines))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sspl\surface_style_parameter_line.
+        style_of_parameter_lines\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (sspl\surface_style_parameter_line.
+        style_of_parameter_lines\curve_style.curve_width))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CURVE_STYLE_FONT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT'] * TYPEOF
+        (sspl\surface_style_parameter_line.
+        style_of_parameter_lines\curve_style.curve_font)) = 1))
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_RENDERING'
+        IN TYPEOF
+        (sspl\surface_style_parameter_line.style_of_parameter_lines))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sspl\surface_style_parameter_line.style_of_parameter_lines\
+        curve_style_rendering.rendering_properties.rendered_colour))
+        = 1))) )) = 0))) = 0))) = 0))) = 0;
+	WR12 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (sscg <* QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_CONTROL_GRID' IN TYPEOF (sses)) |
+        NOT ((
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF (sscg\surface_style_control_grid.style_of_control_grid))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sscg\surface_style_control_grid.
+        style_of_control_grid\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (sscg\surface_style_control_grid.
+        style_of_control_grid\curve_style.curve_width))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CURVE_STYLE_FONT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT'] * TYPEOF
+        (sscg\surface_style_control_grid.
+        style_of_control_grid\curve_style.curve_font)) = 1))
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_RENDERING'
+        IN TYPEOF (sscg\surface_style_control_grid.style_of_control_grid))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sscg\surface_style_control_grid.style_of_control_grid\
+        curve_style_rendering.rendering_properties.rendered_colour))
+        = 1))) )) = 0))) = 0))) = 0))) = 0;
+	WR13 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (sssh <* QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_SILHOUETTE' IN TYPEOF (sses)) |
+        NOT ((
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF (sssh\surface_style_silhouette.style_of_silhouette))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sssh\surface_style_silhouette.
+        style_of_silhouette\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (sssh\surface_style_silhouette.
+        style_of_silhouette\curve_style.curve_width))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CURVE_STYLE_FONT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT'] * TYPEOF
+        (sssh\surface_style_silhouette.
+        style_of_silhouette\curve_style.curve_font)) = 1)) 
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_RENDERING'
+        IN TYPEOF (sssh\surface_style_silhouette.style_of_silhouette))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sssh\surface_style_silhouette.style_of_silhouette\
+        curve_style_rendering.rendering_properties.rendered_colour))
+        = 1))) )) = 0))) = 0))) = 0))) = 0;
+	WR14 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (sssc <* QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_SEGMENTATION_CURVE' IN TYPEOF (sses)) |
+        NOT ((
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF
+        (sssc\surface_style_segmentation_curve.style_of_segmentation_curve))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sssc\surface_style_segmentation_curve.
+        style_of_segmentation_curve\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (sssc\surface_style_segmentation_curve.
+        style_of_segmentation_curve\curve_style.curve_width))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CURVE_STYLE_FONT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT'] * TYPEOF
+        (sssc\surface_style_segmentation_curve.
+        style_of_segmentation_curve\curve_style.curve_font)) = 1)) 
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_RENDERING'
+        IN TYPEOF (sssc\surface_style_segmentation_curve.
+        style_of_segmentation_curve))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sssc\surface_style_segmentation_curve.style_of_segmentation_curve\
+        curve_style_rendering.rendering_properties.rendered_colour))
+        = 1))) )) = 0))) = 0))) = 0))) = 0;
+	WR15 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (ssbd <* QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_BOUNDARY' IN TYPEOF (sses)) |
+        NOT ((
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF (ssbd\surface_style_boundary.style_of_boundary))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (ssbd\surface_style_boundary.
+        style_of_boundary\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (ssbd\surface_style_boundary.
+        style_of_boundary\curve_style.curve_width))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CURVE_STYLE_FONT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT'] * TYPEOF
+        (ssbd\surface_style_boundary.
+        style_of_boundary\curve_style.curve_font)) = 1)) 
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_RENDERING'
+        IN TYPEOF (ssbd\surface_style_boundary.style_of_boundary))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (ssbd\surface_style_boundary.style_of_boundary\
+        curve_style_rendering.rendering_properties.rendered_colour))
+        = 1))) )) = 0))) = 0))) = 0))) = 0;
+	WR16 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (ssre <* QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_RENDERING' IN TYPEOF (sses)) |
+        NOT
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (ssre\surface_style_rendering.surface_colour)) = 1)))
+        = 0))) = 0))) = 0))) = 0;
+END_ENTITY;
+
+
+ENTITY min_and_major_ply_orientation_basis
+	SUBTYPE OF (representation_item_relationship, geometric_representation_item);
+	SELF\representation_item_relationship.related_representation_item : axis2_placement_3d;
+	SELF\representation_item_relationship.relating_representation_item : axis2_placement_3d;
+DERIVE
+	major_orientation_basis : axis2_placement_3d := SELF\representation_item_relationship.related_representation_item;
+	minor_orientation_basis : axis2_placement_3d := SELF\representation_item_relationship.relating_representation_item;
+END_ENTITY;
+
+
+ENTITY modified_geometric_tolerance
+	SUBTYPE OF (geometric_tolerance);
+	modifier : limit_condition;
+END_ENTITY;
+
+
+ENTITY modified_solid
+	ABSTRACT SUPERTYPE OF (ONEOF (edge_blended_solid, sculptured_solid, shelled_solid, modified_solid_with_placed_configuration))
+	SUBTYPE OF (solid_model);
+	rationale : text;
+	base_solid : base_solid_select;
+END_ENTITY;
+
+
+ENTITY modified_solid_with_placed_configuration
+	ABSTRACT SUPERTYPE OF (ONEOF (solid_with_depression, solid_with_protrusion, solid_with_shape_element_pattern))
+	SUBTYPE OF (modified_solid);
+	placing : axis2_placement_3d;
+END_ENTITY;
+
+
+ENTITY moments_of_inertia_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : (SIZEOF(SELF.items) = 1) AND 
+ (SIZEOF( QUERY( i <* SELF.items | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'COMPOUND_REPRESENTATION_ITEM' IN TYPEOF(i)) AND 
+  (i.name = 'moments of inertia matrix') )) = 1);
+	WR2 : SIZEOF( QUERY( i <* SELF.items | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'COMPOUND_REPRESENTATION_ITEM' IN TYPEOF(i)) AND 
+  ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'LIST_REPRESENTATION_ITEM' IN TYPEOF(i\compound_representation_item.item_element)) AND 
+  value_range_aggregate_rep_item (i\compound_representation_item.item_element) )) = 1;
+END_ENTITY;
+
+
+ENTITY multi_language_attribute_assignment
+	SUBTYPE OF (attribute_value_assignment);
+	items : SET [1:?] OF multi_language_attribute_item;
+DERIVE
+	translation_language : language := language_indication[1]\attribute_classification_assignment.assigned_class;
+INVERSE
+	language_indication: SET [1:1] OF attribute_language_assignment FOR items;
+WHERE
+	WR1 : (SELF\attribute_value_assignment.role.name = 'alternate language');
+	WR2 : SIZEOF( QUERY( ala <* language_indication |  
+   (ala\attribute_classification_assignment.attribute_name = 'attribute_value') AND 
+   (ala\attribute_classification_assignment.role.name='translated') )) = 1;
+	WR3 : SELF\attribute_value_assignment.attribute_name <> '';
+	WR4 : SIZEOF(QUERY(ci <* items |
+SIZEOF(QUERY(ata <* USEDIN(ci, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
+(ata\attribute_value_assignment.attribute_name = SELF\attribute_value_assignment.attribute_name) AND 
+(ata.translation_language :=: translation_language) ))>1 )) =0;
+	WR5 : SIZEOF(QUERY(ci <* items |
+SIZEOF(QUERY(ata <* USEDIN(ci, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
+ (ata\attribute_classification_assignment.role.name='primary') AND
+ (ata\attribute_classification_assignment.attribute_name= SELF\attribute_value_assignment.attribute_name) AND 
+ (ata\attribute_classification_assignment.assigned_class :=: translation_language) ))>0 )) =0;
+END_ENTITY;
+
+
+ENTITY multiple_arity_boolean_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (boolean_expression, multiple_arity_generic_expression);
+	SELF\multiple_arity_generic_expression.operands : LIST [2:?] OF boolean_expression;
+END_ENTITY;
+
+
+ENTITY multiple_arity_generic_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (generic_expression);
+	operands : LIST [2:?] OF generic_expression;
+END_ENTITY;
+
+
+ENTITY multiple_arity_numeric_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (numeric_expression, multiple_arity_generic_expression);
+	SELF\multiple_arity_generic_expression.operands : LIST [2:?] OF numeric_expression;
+END_ENTITY;
+
+
+ENTITY name_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_name : label;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY name_attribute;
+	attribute_value : label;
+	named_item : name_attribute_select;
+END_ENTITY;
+
+
+ENTITY named_unit
+	SUPERTYPE OF ((ONEOF (si_unit, conversion_based_unit, context_dependent_unit) ANDOR ONEOF (length_unit, mass_unit, time_unit, electric_current_unit, thermodynamic_temperature_unit, amount_of_substance_unit, luminous_flux_unit, luminous_intensity_unit, plane_angle_unit, solid_angle_unit, ratio_unit)));
+	dimensions : dimensional_exponents;
+END_ENTITY;
+
+
+ENTITY next_assembly_usage_occurrence
+	SUBTYPE OF (assembly_component_usage);
+END_ENTITY;
+
+
+ENTITY non_manifold_surface_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF (QUERY (it <* SELF.items |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D'] * TYPEOF (it)) = 1)))
+       = 0;
+	WR2 : SIZEOF (QUERY (it <* SELF.items |
+       SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'] * TYPEOF (it)) = 1)) > 0;
+	WR3 : SIZEOF (QUERY (mi <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+       'NON_MANIFOLD_SURFACE_SHAPE_REPRESENTATION'
+       IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation))
+       AND
+       (SIZEOF(QUERY (mr_it <*
+       mi\mapped_item.mapping_source.mapped_representation.items |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL'
+       IN TYPEOF (mr_it)))) > 0 )))) = 0;
+	WR4 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_FACE'] * TYPEOF (fa)) = 1)))
+       = 0))) = 0))) = 0;
+	WR5 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (f_sf <* QUERY (fa <* cfs.cfs_faces |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE' IN TYPEOF (fa))) |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (f_sf))
+       OR
+       (nmsf_surface_check(f_sf\face_surface.face_geometry))))) = 0))) 
+       = 0))) = 0;
+	WR6 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (o_fa <* QUERY (fa <* cfs.cfs_faces |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_FACE' IN TYPEOF (fa))) |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF 
+       (o_fa\oriented_face.face_element))
+       OR
+       (nmsf_surface_check
+       (o_fa\oriented_face.face_element\face_surface.face_geometry)))))
+       = 0))) = 0))) = 0;
+	WR7 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (bnds <* fa.bounds |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP']
+       * TYPEOF (bnds.bound)) = 1))) = 0)))) = 0))) = 0))) = 0;
+	WR8 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items|
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list |
+       NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN TYPEOF 
+       (oe.edge_element)))) = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR9 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe_cv <* QUERY (oe <* 
+       elp_fbnds\path.edge_list |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN TYPEOF (oe.edge_element)) |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE'] * 
+       TYPEOF (oe_cv.edge_element\edge_curve.edge_geometry)) 
+       = 1))) = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR10 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list |
+       NOT (nmsf_curve_check (oe.edge_element\edge_curve.edge_geometry)))) 
+       = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR11 : SIZEOF (QUERY(fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list|
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF
+       (oe.edge_element.edge_start))
+       AND
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN
+       TYPEOF (oe.edge_element.edge_end))))) 
+       = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR12 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list |
+       NOT ((SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEGENERATE_PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_SURFACE'] * TYPEOF
+       (oe.edge_element.edge_start\vertex_point.vertex_geometry)) = 1)
+       AND
+       (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEGENERATE_PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_SURFACE'] * TYPEOF
+       (oe.edge_element.edge_end\vertex_point.vertex_geometry)) = 1
+       )))) = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR13 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <* 
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (vlp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF
+       (vlp_fbnds\vertex_loop.loop_vertex)))) = 0)))) = 0))) 
+       = 0))) = 0;
+	WR14 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <* 
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (vlp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEGENERATE_PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_SURFACE'] * TYPEOF
+       (vlp_fbnds\vertex_loop.loop_vertex\vertex_point.vertex_geometry)) 
+       = 1))) = 0)))) = 0))) = 0))) = 0;
+END_ENTITY;
+
+
+ENTITY null_representation_item
+	SUBTYPE OF (representation_item);
+END_ENTITY;
+
+
+ENTITY numeric_expression
+	ABSTRACT SUPERTYPE OF (ONEOF (simple_numeric_expression, unary_numeric_expression, binary_numeric_expression, multiple_arity_numeric_expression))
+	SUBTYPE OF (expression);
+DERIVE
+	is_int : LOGICAL := is_int_expr (SELF);
+	sql_mappable : LOGICAL := is_SQL_mappable (SELF);
+END_ENTITY;
+
+
+ENTITY object_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY offset_curve_2d
+	SUBTYPE OF (curve);
+	basis_curve : curve;
+	distance : length_measure;
+	self_intersect : LOGICAL;
+WHERE
+	WR1 : basis_curve.dim = 2;
+END_ENTITY;
+
+
+ENTITY offset_curve_3d
+	SUBTYPE OF (curve);
+	basis_curve : curve;
+	distance : length_measure;
+	self_intersect : LOGICAL;
+	ref_direction : direction;
+WHERE
+	WR1 : (basis_curve.dim = 3) AND (ref_direction.dim = 3);
+END_ENTITY;
+
+
+ENTITY offset_surface
+	SUBTYPE OF (surface);
+	basis_surface : surface;
+	distance : length_measure;
+	self_intersect : LOGICAL;
+END_ENTITY;
+
+
+ENTITY one_direction_repeat_factor
+	SUBTYPE OF (geometric_representation_item);
+	repeat_factor : vector;
+END_ENTITY;
+
+
+ENTITY open_shell
+	SUBTYPE OF (connected_face_set);
+END_ENTITY;
+
+
+ENTITY ordinal_date
+	SUBTYPE OF (date);
+	day_component : day_in_year_number;
+WHERE
+	WR1 : (NOT leap_year(SELF.year_component) AND { 1 <= day_component <= 365 }) OR (leap_year(SELF.year_component) AND { 1 <= day_component <= 366 });
+END_ENTITY;
+
+
+ENTITY ordinate_dimension
+	SUBTYPE OF (projection_directed_callout);
+END_ENTITY;
+
+
+ENTITY organization;
+	id : OPTIONAL identifier;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY organization_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_organization : organization;
+	role : organization_role;
+END_ENTITY;
+
+
+ENTITY organization_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_organization : organization;
+	related_organization : organization;
+END_ENTITY;
+
+
+ENTITY organization_role;
+	name : label;
+DERIVE
+	description : text := get_description_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY organizational_address
+	SUBTYPE OF (address);
+	organizations : SET [1:?] OF organization;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY organizational_project;
+	name : label;
+	description : OPTIONAL text;
+	responsible_organizations : SET [1:?] OF organization;
+DERIVE
+	id : identifier := get_id_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY organizational_project_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_organizational_project : organizational_project;
+	role : organizational_project_role;
+END_ENTITY;
+
+
+ENTITY organizational_project_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_organizational_project : organizational_project;
+	related_organizational_project : organizational_project;
+END_ENTITY;
+
+
+ENTITY organizational_project_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY oriented_closed_shell
+	SUBTYPE OF (closed_shell);
+	closed_shell_element : closed_shell;
+	orientation : BOOLEAN;
+DERIVE
+	SELF\connected_face_set.cfs_faces : SET [1:?] OF face := conditional_reverse(SELF.orientation,
+                                   SELF.closed_shell_element.cfs_faces);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_CLOSED_SHELL' 
+                IN TYPEOF (SELF.closed_shell_element));
+END_ENTITY;
+
+
+ENTITY oriented_edge
+	SUBTYPE OF (edge);
+	edge_element : edge;
+	orientation : BOOLEAN;
+DERIVE
+	SELF\edge.edge_end : vertex := boolean_choose (SELF.orientation,
+                                            SELF.edge_element.edge_end,
+                                            SELF.edge_element.edge_start);
+	SELF\edge.edge_start : vertex := boolean_choose (SELF.orientation,
+                                            SELF.edge_element.edge_start,
+                                            SELF.edge_element.edge_end);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_EDGE' IN TYPEOF (SELF.edge_element));
+END_ENTITY;
+
+
+ENTITY oriented_face
+	SUBTYPE OF (face);
+	face_element : face;
+	orientation : BOOLEAN;
+DERIVE
+	SELF\face.bounds : SET [1:?] OF face_bound := conditional_reverse(SELF.orientation,SELF.face_element.bounds);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_FACE' IN TYPEOF (SELF.face_element));
+END_ENTITY;
+
+
+ENTITY oriented_open_shell
+	SUBTYPE OF (open_shell);
+	open_shell_element : open_shell;
+	orientation : BOOLEAN;
+DERIVE
+	SELF\connected_face_set.cfs_faces : SET [1:?] OF face := conditional_reverse(SELF.orientation,
+                                      SELF.open_shell_element.cfs_faces);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_OPEN_SHELL' 
+                IN TYPEOF (SELF.open_shell_element));
+END_ENTITY;
+
+
+ENTITY oriented_path
+	SUBTYPE OF (path);
+	path_element : path;
+	orientation : BOOLEAN;
+DERIVE
+	SELF\path.edge_list : LIST [1:?] OF  UNIQUE oriented_edge := conditional_reverse(SELF.orientation,
+                                         SELF.path_element.edge_list);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_PATH' IN TYPEOF (SELF.path_element));
+END_ENTITY;
+
+
+ENTITY oriented_surface
+	SUBTYPE OF (surface);
+	orientation : BOOLEAN;
+END_ENTITY;
+
+
+ENTITY outer_boundary_curve
+	SUBTYPE OF (boundary_curve);
+END_ENTITY;
+
+
+ENTITY over_riding_styled_item
+	SUBTYPE OF (styled_item);
+	over_ridden_style : styled_item;
+END_ENTITY;
+
+
+ENTITY package_product_concept_feature
+	SUBTYPE OF (product_concept_feature);
+WHERE
+	WR1 : NOT ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONDITIONAL_CONCEPT_FEATURE' IN TYPEOF ( SELF ) );
+	WR2 : SIZEOF ( QUERY 
+									( 
+										cfr <* USEDIN ( SELF , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONCEPT_FEATURE_RELATIONSHIP.' +'RELATING_PRODUCT_CONCEPT_FEATURE' ) 
+										| 
+										('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONCEPT_FEATURE_RELATIONSHIP_WITH_CONDITION' IN TYPEOF (cfr ) ) 
+										AND 
+										( SIZEOF ( QUERY 
+																( 
+																	ipcf <* USEDIN ( cfr , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONDITIONAL_CONCEPT_FEATURE.' +	'CONDITION' ) 
+																	| 
+																	'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'INCLUSION_PRODUCT_CONCEPT_FEATURE' IN TYPEOF ( ipcf ) 
+																)
+															)= 1 
+										)
+									)
+							)>0;
+END_ENTITY;
+
+
+ENTITY parabola
+	SUBTYPE OF (conic);
+	focal_dist : length_measure;
+WHERE
+	WR1 : focal_dist <> 0.0;
+END_ENTITY;
+
+
+ENTITY parallel_offset
+	SUBTYPE OF (derived_shape_aspect);
+	offset : measure_with_unit;
+WHERE
+	WR1 : SIZEOF (SELF\derived_shape_aspect.deriving_relationships)= 1;
+END_ENTITY;
+
+
+ENTITY parallelism_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) < 3;
+END_ENTITY;
+
+
+ENTITY parametric_representation_context
+	SUBTYPE OF (representation_context);
+END_ENTITY;
+
+
+ENTITY part_laminate_table
+	SUPERTYPE OF (ONEOF (composite_assembly_table, ply_laminate_table))
+	SUBTYPE OF (laminate_table);
+END_ENTITY;
+
+
+ENTITY partial_document_with_structured_text_representation_assignment
+	SUBTYPE OF (applied_document_usage_constraint_assignment, characterized_object);
+END_ENTITY;
+
+
+ENTITY path
+	SUPERTYPE OF (ONEOF (edge_loop, oriented_path))
+	SUBTYPE OF (topological_representation_item);
+	edge_list : LIST [1:?] OF  UNIQUE oriented_edge;
+WHERE
+	WR1 : path_head_to_tail(SELF);
+END_ENTITY;
+
+
+ENTITY pcurve
+	SUBTYPE OF (curve);
+	basis_surface : surface;
+	reference_to_curve : definitional_representation;
+WHERE
+	WR1 : SIZEOF(reference_to_curve\representation.items) = 1;
+	WR2 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE' IN TYPEOF
+                    (reference_to_curve\representation.items[1]);
+	WR3 : reference_to_curve\representation.items[1]\
+                               geometric_representation_item.dim =2;
+END_ENTITY;
+
+
+ENTITY percentage_laminate_definition
+	SUBTYPE OF (product_definition);
+WHERE
+	WR1 : SIZEOF (QUERY (pdr <* USEDIN (SELF, 
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'PRODUCT_DEFINITION_RELATIONSHIP.' +
+                             'RELATING_PRODUCT_DEFINITION') |
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'NEXT_ASSEMBLY_USAGE_OCCURRENCE' IN
+                             TYPEOF (pdr))) > 0;
+END_ENTITY;
+
+
+ENTITY percentage_laminate_table
+	SUBTYPE OF (zone_structural_makeup);
+END_ENTITY;
+
+
+ENTITY percentage_ply_definition
+	SUBTYPE OF (product_definition);
+WHERE
+	WR1 : SIZEOF (QUERY (pdr <* USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRODUCT_DEFINITION_RELATIONSHIP.RELATING_PRODUCT_DEFINITION') |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PERCENTAGE_LAMINATE_DEFINITION' 
+        IN TYPEOF (pdr.related_product_definition)) AND
+        (pdr.name = 'makeup and properties'))) = 0;
+END_ENTITY;
+
+
+ENTITY perpendicular_to
+	SUBTYPE OF (derived_shape_aspect);
+WHERE
+	WR1 : SIZEOF (SELF\derived_shape_aspect.deriving_relationships)= 1;
+END_ENTITY;
+
+
+ENTITY perpendicularity_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 3;
+END_ENTITY;
+
+
+ENTITY person;
+	id : identifier;
+	last_name : OPTIONAL label;
+	first_name : OPTIONAL label;
+	middle_names : OPTIONAL LIST [1:?] OF label;
+	prefix_titles : OPTIONAL LIST [1:?] OF label;
+	suffix_titles : OPTIONAL LIST [1:?] OF label;
+WHERE
+	WR1 : EXISTS(last_name) OR EXISTS(first_name);
+END_ENTITY;
+
+
+ENTITY person_and_organization;
+	the_person : person;
+	the_organization : organization;
+DERIVE
+	description : text := get_description_value(SELF);
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY person_and_organization_address
+	SUBTYPE OF (organizational_address, personal_address);
+	SELF\organizational_address.organizations : SET [1:1] OF organization;
+	SELF\personal_address.people : SET [1:1] OF person;
+WHERE
+	WR1 : SIZEOF(QUERY(pao <* USEDIN (SELF\personal_address.people[1], 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PERSON_AND_ORGANIZATION.THE_PERSON') | pao.the_organization :=: SELF\organizational_address.organizations[1])) = 1;
+END_ENTITY;
+
+
+ENTITY person_and_organization_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_person_and_organization : person_and_organization;
+	role : person_and_organization_role;
+END_ENTITY;
+
+
+ENTITY person_and_organization_role;
+	name : label;
+DERIVE
+	description : text := get_description_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY personal_address
+	SUBTYPE OF (address);
+	people : SET [1:?] OF person;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY physical_breakdown_context
+	SUBTYPE OF (breakdown_context);
+END_ENTITY;
+
+
+ENTITY physical_element_usage
+	SUBTYPE OF (breakdown_element_usage);
+END_ENTITY;
+
+
+ENTITY picture_representation
+	SUBTYPE OF (presentation_view);
+	SELF\representation.items : SET [2:?] OF picture_representation_item_select;
+INVERSE
+	size: presentation_size FOR unit;
+WHERE
+    WR1: SIZEOF(QUERY(item <* items | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM' IN TYPEOF(item))) = 1;
+    WR2: SIZEOF (QUERY (se <* QUERY (item <* SELF.items | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM' IN TYPEOF (item))) 
+         | NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PICTURE_REPRESENTATION_ITEM' 
+                IN TYPEOF (se\styled_item.item)) )) = 0;
+END_ENTITY;
+
+
+ENTITY picture_representation_item
+	ABSTRACT SUPERTYPE OF (ONEOF (externally_defined_picture_representation_item, predefined_picture_representation_item))
+	SUBTYPE OF (bytes_representation_item);
+END_ENTITY;
+
+
+ENTITY placed_datum_target_feature
+	SUBTYPE OF (datum_target);
+DERIVE
+	representation_associations : SET [0:?] OF property_definition_representation := get_shape_aspect_property_definition_representations(SELF);
+WHERE
+	WR1 : SELF.description IN ['point','line','rectangle','circle', 'circular line'];
+	WR2 : SIZEOF (QUERY (pdr <* representation_associations | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION_WITH_PARAMETERS' IN TYPEOF (pdr.used_representation) )) = 1;
+	WR3 : valid_datum_target_parameters(SELF);
+END_ENTITY;
+
+
+ENTITY placed_feature
+	SUBTYPE OF (shape_aspect);
+END_ENTITY;
+
+
+ENTITY placement
+	SUPERTYPE OF (ONEOF (axis1_placement, axis2_placement_2d, axis2_placement_3d))
+	SUBTYPE OF (geometric_representation_item);
+	location : cartesian_point;
+END_ENTITY;
+
+
+ENTITY planar_box
+	SUBTYPE OF (planar_extent);
+	placement : axis2_placement;
+END_ENTITY;
+
+
+ENTITY planar_extent
+	SUBTYPE OF (geometric_representation_item);
+	size_in_x : length_measure;
+	size_in_y : length_measure;
+END_ENTITY;
+
+
+ENTITY plane
+	SUBTYPE OF (elementary_surface);
+END_ENTITY;
+
+
+ENTITY plane_angle_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE_ANGLE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY plane_angle_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY plus_minus_tolerance;
+	range : tolerance_method_definition;
+	toleranced_dimension : dimensional_characteristic;
+UNIQUE
+	UR1 : toleranced_dimension;
+END_ENTITY;
+
+
+ENTITY ply_laminate_definition
+	SUBTYPE OF (product_definition);
+WHERE
+	WR1 : SIZEOF (QUERY (pdr <* USEDIN (SELF, 
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'PRODUCT_DEFINITION_RELATIONSHIP.' +
+                             'RELATING_PRODUCT_DEFINITION') |
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'NEXT_ASSEMBLY_USAGE_OCCURRENCE' IN
+                             TYPEOF (pdr))) = 1;
+END_ENTITY;
+
+
+ENTITY ply_laminate_sequence_definition
+	SUBTYPE OF (product_definition);
+WHERE
+	WR1 : SIZEOF (QUERY (pdr <* USEDIN (SELF, 
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'PRODUCT_DEFINITION_RELATIONSHIP.' +
+                             'RELATING_PRODUCT_DEFINITION') |
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'NEXT_ASSEMBLY_USAGE_OCCURRENCE' IN
+                             TYPEOF (pdr))) > 0;
+END_ENTITY;
+
+
+ENTITY ply_laminate_table
+	SUBTYPE OF (part_laminate_table);
+END_ENTITY;
+
+
+ENTITY point
+	SUPERTYPE OF (ONEOF (cartesian_point, point_on_curve, point_on_surface, point_replica, degenerate_pcurve))
+	SUBTYPE OF (geometric_representation_item);
+END_ENTITY;
+
+
+ENTITY point_and_vector
+	SUBTYPE OF (compound_representation_item, geometric_representation_item);
+	SELF\compound_representation_item.item_element : point_and_vector_members;
+END_ENTITY;
+
+
+ENTITY point_on_curve
+	SUBTYPE OF (point);
+	basis_curve : curve;
+	point_parameter : parameter_value;
+END_ENTITY;
+
+
+ENTITY point_on_surface
+	SUBTYPE OF (point);
+	basis_surface : surface;
+	point_parameter_u : parameter_value;
+	point_parameter_v : parameter_value;
+END_ENTITY;
+
+
+ENTITY point_path
+	SUBTYPE OF (compound_representation_item, geometric_representation_item);
+	SELF\compound_representation_item.item_element : point_path_members;
+END_ENTITY;
+
+
+ENTITY point_replica
+	SUBTYPE OF (point);
+	parent_pt : point;
+	transformation : cartesian_transformation_operator;
+WHERE
+	WR1 : transformation.dim = parent_pt.dim;
+	WR2 : acyclic_point_replica (SELF,parent_pt);
+END_ENTITY;
+
+
+ENTITY point_style
+	SUBTYPE OF (founded_item);
+	name : label;
+	marker : marker_select;
+	marker_size : size_select;
+	marker_colour : colour;
+END_ENTITY;
+
+
+ENTITY polar_complex_number_literal
+	SUBTYPE OF (generic_literal);
+	radius : REAL;
+	angle : REAL;
+WHERE
+	WR1 : radius >= 0;
+	WR2 : { 0 <= angle < 2*PI };
+END_ENTITY;
+
+
+ENTITY poly_loop
+	SUBTYPE OF (loop, geometric_representation_item);
+	polygon : LIST [3:?] OF  UNIQUE cartesian_point;
+END_ENTITY;
+
+
+ENTITY polyline
+	SUBTYPE OF (bounded_curve);
+	points : LIST [2:?] OF cartesian_point;
+END_ENTITY;
+
+
+ENTITY position_tolerance
+	SUBTYPE OF (geometric_tolerance);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE' IN TYPEOF (SELF)) OR ( SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 3);
+END_ENTITY;
+
+
+ENTITY positioned_sketch
+	SUBTYPE OF (geometric_representation_item);
+	sketch_basis : sketch_basis_select;
+	auxiliary_elements : SET [0:?] OF auxiliary_geometric_representation_item;
+WHERE
+	WR1 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_BOUNDED_SURFACE' IN 
+    TYPEOF(sketch_basis)) AND NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE' IN
+    TYPEOF(sketch_basis\curve_bounded_surface.basis_surface)));
+	WR2 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE' IN TYPEOF(sketch_basis)) AND
+    NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE' IN TYPEOF(sketch_basis\face_surface.face_geometry)));
+	WR3 : SIZEOF(QUERY(q <* auxiliary_elements | (SIZEOF(TYPEOF(q) * 
+    ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT','AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE']) = 0))) = 0;
+	WR4 : SIZEOF(QUERY(q <* auxiliary_elements | 
+    q\geometric_representation_item.dim <> 3)) = 0;
+END_ENTITY;
+
+
+ENTITY power_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POWER_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY power_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.watt);
+END_ENTITY;
+
+
+ENTITY pre_defined_colour
+	SUBTYPE OF (pre_defined_item, colour);
+END_ENTITY;
+
+
+ENTITY pre_defined_curve_font
+	SUBTYPE OF (pre_defined_item);
+END_ENTITY;
+
+
+ENTITY pre_defined_dimension_symbol
+	SUBTYPE OF (pre_defined_symbol);
+WHERE
+	WR1 : SELF.name IN [ 'arc length' , 'conical taper' , 'counterbore' , 'countersink' , 'depth' , 'diameter' , 'plus minus' , 'radius' , 'slope' , 'spherical diameter' , 'spherical radius' , 'square'];
+END_ENTITY;
+
+
+ENTITY pre_defined_geometrical_tolerance_symbol
+	SUBTYPE OF (pre_defined_symbol);
+WHERE
+	WR1 : SELF.name IN ['angularity' , 'basic dimension' , 'blanked datum reference' , 'circular runout' , 'circularity' , 'concentricity' , 'cylindricity' , 'datum target identification' , 'diameter' , 'filled datum reference' , 'flatness' , 'least material condition' , 'maximum material condition' , 'parallelism' , 'perpendicularity' , 'position' , 'profile of a line' , 'profile of a surface' , 'projected tolerance zone' , 'regardless of feature size' , 'straightness' , 'symmetry' , 'total runout' ];
+END_ENTITY;
+
+
+ENTITY pre_defined_item;
+	name : label;
+END_ENTITY;
+
+
+ENTITY pre_defined_marker
+	SUBTYPE OF (pre_defined_item);
+END_ENTITY;
+
+
+ENTITY pre_defined_point_marker_symbol
+	SUBTYPE OF (pre_defined_marker, pre_defined_symbol);
+WHERE
+	WR1 : SELF.name IN ['asterisk','circle','dot','plus','square','triangle','x'];
+END_ENTITY;
+
+
+ENTITY pre_defined_surface_condition_symbol
+	SUBTYPE OF (pre_defined_symbol);
+WHERE
+	WR1 : SELF.name IN ['000' , '010' , '020' , '030' , '040' , '050' , '060' , '070' , '001' , '011' , '021' , '031' , '041' , '051' , '061' , '071' , '100' , '110' , '120' , '130' , '140' , '150' , '160' , '170' , '101' , '111' , '121' , '131' , '141' , '151' , '161' , '171' , '200' , '210' , '220' , '230' , '240' , '250' , '260' , '270' , '201' , '211' , '221' , '231' , '241' , '251' , '261' , '271'];
+END_ENTITY;
+
+
+ENTITY pre_defined_surface_side_style
+	SUBTYPE OF (pre_defined_item);
+END_ENTITY;
+
+
+ENTITY pre_defined_symbol
+	SUBTYPE OF (pre_defined_item);
+END_ENTITY;
+
+
+ENTITY pre_defined_terminator_symbol
+	SUBTYPE OF (pre_defined_symbol);
+WHERE
+	WR1 : SELF.name IN ['blanked arrow', 'blanked box', 'blanked dot', 'blanked triangle', 'dimension origin', 'filled arrow', 'filled box', 'filled dot', 'integral symbol', 'open arrow', 'slash', 'unfilled arrow', 'unfilled triangle', 'filled triangle'];
+END_ENTITY;
+
+
+ENTITY pre_defined_text_font
+	SUBTYPE OF (pre_defined_item);
+END_ENTITY;
+
+
+ENTITY pre_defined_tile
+	SUBTYPE OF (pre_defined_item);
+END_ENTITY;
+
+
+ENTITY precision_qualifier;
+	precision_value : INTEGER;
+END_ENTITY;
+
+
+ENTITY predefined_picture_representation_item
+	SUBTYPE OF (picture_representation_item);
+WHERE
+	WR1 : SELF\representation_item.name IN pre_defined_picture_representation_types;
+END_ENTITY;
+
+
+ENTITY presentation_area
+	SUBTYPE OF (presentation_representation);
+WHERE
+	WR1 : ((SIZEOF (QUERY (ais <* USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                                 'AREA_IN_SET.AREA') | 
+             SIZEOF (USEDIN (ais, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                  'PRESENTATION_SIZE.UNIT')) =1)) > 0) OR
+            (SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                   'PRESENTATION_SIZE.UNIT')) =1));
+END_ENTITY;
+
+
+ENTITY presentation_layer_assignment;
+	name : label;
+	description : text;
+	assigned_items : SET [1:?] OF layered_item;
+END_ENTITY;
+
+
+ENTITY presentation_representation
+	SUPERTYPE OF (ONEOF (presentation_area, presentation_view))
+	SUBTYPE OF (representation);
+	SELF\representation.context_of_items : geometric_representation_context;
+WHERE
+	WR1 : SELF\representation.
+           context_of_items\geometric_representation_context.
+           coordinate_space_dimension = 2;
+	WR2 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_AREA' IN TYPEOF (SELF))
+           OR
+           (SIZEOF (QUERY (prr <* USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                                'REPRESENTATION_RELATIONSHIP.REP_2') | 
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_REPRESENTATION' IN
+           TYPEOF (prr\representation_relationship.rep_1))) > 0)
+           OR 
+           (SIZEOF(QUERY( rm <* USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 
+                                             'REPRESENTATION_MAP.'+ 
+                                             'MAPPED_REPRESENTATION') | 
+           SIZEOF(QUERY( mi <* USEDIN(rm, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                                          'MAPPED_ITEM.'+
+                                          'MAPPING_SOURCE') |   
+           SIZEOF(QUERY( rep <* using_representations (mi) |                              
+                                        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                                        'PRESENTATION_REPRESENTATION' IN 
+                                        TYPEOF (rep))) > 0
+           )) > 0))  
+           > 0);
+END_ENTITY;
+
+
+ENTITY presentation_set;
+INVERSE
+	areas: SET [1:?] OF area_in_set FOR in_set;
+END_ENTITY;
+
+
+ENTITY presentation_size;
+	unit : presentation_size_assignment_select;
+	size : planar_box;
+UNIQUE
+	UR1 : unit;
+WHERE
+	WR1 : (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_REPRESENTATION'
+           IN TYPEOF (SELF.unit)) AND
+           item_in_context (SELF.size, 
+                            SELF.unit\representation.context_of_items)
+           )
+           OR
+           (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AREA_IN_SET'
+           IN TYPEOF (SELF.unit)) AND
+           (SIZEOF (QUERY ( ais <* SELF.unit\area_in_set.in_set.areas |
+                NOT item_in_context (SELF.size, ais.area\representation.
+                                                context_of_items) )) = 0));
+END_ENTITY;
+
+
+ENTITY presentation_style_assignment
+	SUBTYPE OF (founded_item);
+	styles : SET [1:?] OF presentation_style_select;
+WHERE
+	WR1 : SIZEOF (QUERY (style1 <* SELF.styles |
+           NOT (SIZEOF (QUERY (style2 <* (SELF.styles - style1) |
+           NOT ((TYPEOF (style1) <> TYPEOF (style2)) OR
+             (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+                       'SURFACE_STYLE_USAGE',
+                       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                       'EXTERNALLY_DEFINED_STYLE'] *
+                     TYPEOF (style1)) = 1)
+           ))) = 0
+         ))) = 0;
+	WR2 : SIZEOF (QUERY (style1 <* SELF.styles |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE' IN
+         TYPEOF(style1)
+         )) <= 2;
+	WR3 : SIZEOF (QUERY (style1 <* SELF.styles |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE' IN TYPEOF (style1)) AND 
+         (SIZEOF (QUERY (style2 <* (SELF.styles - style1) |
+           ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE' IN TYPEOF (style2)) AND 
+           ((style1\surface_style_usage.side = both) OR 
+           (style2\surface_style_usage.side = both) OR 
+           (style1\surface_style_usage.side = style2\surface_style_usage.side)) )) > 0))) = 0;
+END_ENTITY;
+
+
+ENTITY presentation_style_by_context
+	SUBTYPE OF (presentation_style_assignment);
+	style_context : style_context_select;
+END_ENTITY;
+
+
+ENTITY presentation_view
+	SUBTYPE OF (presentation_representation);
+END_ENTITY;
+
+
+ENTITY presented_item
+	ABSTRACT SUPERTYPE;
+END_ENTITY;
+
+
+ENTITY presented_item_representation;
+	presentation : presentation_representation_select;
+	item : presented_item;
+END_ENTITY;
+
+
+ENTITY pressure_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESSURE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY pressure_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.pascal);
+END_ENTITY;
+
+
+ENTITY procedural_representation
+	SUBTYPE OF (representation);
+	SELF\representation.items : SET [1:?] OF procedural_representation_sequence;
+END_ENTITY;
+
+
+ENTITY procedural_representation_sequence
+	SUBTYPE OF (representation_item);
+	elements : LIST [1:?] OF representation_item;
+	suppressed_items : SET [0:?] OF representation_item;
+	rationale : text;
+WHERE
+	WR1 : SIZEOF(QUERY(q <* suppressed_items | NOT (q IN elements))) = 0;
+END_ENTITY;
+
+
+ENTITY procedural_shape_representation
+	SUBTYPE OF (procedural_representation, shape_representation);
+	SELF\representation.items : SET [1:?] OF procedural_shape_representation_sequence;
+END_ENTITY;
+
+
+ENTITY procedural_shape_representation_sequence
+	SUBTYPE OF (geometric_representation_item, procedural_representation_sequence);
+WHERE
+	WR1 : SIZEOF(QUERY(q <* SELF\procedural_representation_sequence.elements
+    | NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION_ITEM'
+    IN TYPEOF(q)))) = 0;
+END_ENTITY;
+
+
+ENTITY product;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+	frame_of_reference : SET [1:?] OF product_context;
+END_ENTITY;
+
+
+ENTITY product_category;
+	name : label;
+	description : OPTIONAL text;
+DERIVE
+	id : identifier := get_id_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY product_class
+	SUBTYPE OF (product_concept, characterized_object);
+END_ENTITY;
+
+
+ENTITY product_concept;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+	market_context : product_concept_context;
+UNIQUE
+	UR1 : id;
+END_ENTITY;
+
+
+ENTITY product_concept_context
+	SUBTYPE OF (application_context_element);
+	market_segment_type : label;
+END_ENTITY;
+
+
+ENTITY product_concept_feature;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY product_concept_feature_association;
+	name : label;
+	description : OPTIONAL text;
+	concept : product_concept;
+	feature : product_concept_feature;
+END_ENTITY;
+
+
+ENTITY product_concept_feature_category
+	SUBTYPE OF (group);
+WHERE
+	WR1 : SIZEOF(QUERY
+									( 
+										aga <* USEDIN( SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GROUP_ASSIGNMENT.ASSIGNED_GROUP' ) 
+										|
+     								('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'APPLIED_GROUP_ASSIGNMENT' IN TYPEOF(aga)) 
+     								AND
+    								(
+    									( aga.role.name <> 'specification category member' ) 
+    									OR 
+    									( SIZEOF(QUERY 
+    															( 
+    																i <* aga.items 
+    																| 
+    																('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'PRODUCT_CONCEPT_FEATURE' IN TYPEOF ( i ) ) 
+    																AND 
+    																NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'CONDITIONAL_CONCEPT_FEATURE' IN TYPEOF (i))
+    															)
+    													) <> SIZEOF (aga.items)
+    									)
+    								) 
+       						) 
+       				) =0;
+END_ENTITY;
+
+
+ENTITY product_concept_feature_category_usage
+	SUBTYPE OF (group_assignment);
+	items : SET [1:?] OF category_usage_item;
+	SELF\group_assignment.assigned_group : product_concept_feature_category;
+WHERE
+	WR1 : SELF.role.name IN [ 'mandatory category usage', 'optional category usage' ];
+END_ENTITY;
+
+
+ENTITY product_concept_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_product_concept : product_concept;
+	related_product_concept : product_concept;
+END_ENTITY;
+
+
+ENTITY product_context
+	SUBTYPE OF (application_context_element);
+	discipline_type : label;
+END_ENTITY;
+
+
+ENTITY product_definition
+	SUPERTYPE OF (ONEOF (composite_assembly_definition, composite_assembly_sequence_definition, laminate_table, percentage_laminate_definition, percentage_ply_definition, ply_laminate_definition, ply_laminate_sequence_definition, thickness_laminate_definition));
+	id : identifier;
+	description : OPTIONAL text;
+	formation : product_definition_formation;
+	frame_of_reference : product_definition_context;
+DERIVE
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY product_definition_context
+	SUBTYPE OF (application_context_element);
+	life_cycle_stage : label;
+END_ENTITY;
+
+
+ENTITY product_definition_context_association;
+	definition : product_definition;
+	frame_of_reference : product_definition_context;
+	role : product_definition_context_role;
+END_ENTITY;
+
+
+ENTITY product_definition_context_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY product_definition_effectivity
+	SUBTYPE OF (effectivity);
+	usage : product_definition_relationship;
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'EFFECTIVITY_ASSIGNMENT.ASSIGNED_EFFECTIVITY')) = 0;
+END_ENTITY;
+
+
+ENTITY product_definition_element_relationship
+	SUBTYPE OF (group);
+END_ENTITY;
+
+
+ENTITY product_definition_formation;
+	id : identifier;
+	description : OPTIONAL text;
+	of_product : product;
+UNIQUE
+	UR1 : id, of_product;
+END_ENTITY;
+
+
+ENTITY product_definition_formation_relationship;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+	relating_product_definition_formation : product_definition_formation;
+	related_product_definition_formation : product_definition_formation;
+END_ENTITY;
+
+
+ENTITY product_definition_formation_with_specified_source
+	SUBTYPE OF (product_definition_formation);
+	make_or_buy : source;
+END_ENTITY;
+
+
+ENTITY product_definition_group_assignment
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF product_definition_or_product_definition_relationship;
+	SELF\group_assignment.assigned_group : product_definition_element_relationship;
+END_ENTITY;
+
+
+ENTITY product_definition_occurrence_relationship;
+	name : label;
+	description : OPTIONAL text;
+	occurrence : product_definition;
+	occurrence_usage : assembly_component_usage;
+WHERE
+	WR1 : occurrence_usage.relating_product_definition :<>: 
+       occurrence;
+	WR2 : occurrence_usage.related_product_definition :<>: 
+       occurrence;
+	WR3 : occurrence.formation :=:
+       occurrence_usage.related_product_definition.formation;
+END_ENTITY;
+
+
+ENTITY product_definition_relationship;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+	relating_product_definition : product_definition;
+	related_product_definition : product_definition;
+END_ENTITY;
+
+
+ENTITY product_definition_shape
+	SUBTYPE OF (property_definition);
+UNIQUE
+  UR1: SELF\property_definition.definition;
+WHERE
+	WR1 : SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CHARACTERIZED_PRODUCT_DEFINITION', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CHARACTERIZED_OBJECT'] * TYPEOF(SELF\property_definition.definition)) > 0;
+END_ENTITY;
+
+
+ENTITY product_definition_substitute;
+	description : OPTIONAL text;
+	context_relationship : product_definition_relationship;
+	substitute_definition : product_definition;
+DERIVE
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : context_relationship.related_product_definition :<>: substitute_definition;
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY product_definition_usage
+	SUPERTYPE OF (ONEOF (make_from_usage_option, assembly_component_usage))
+	SUBTYPE OF (product_definition_relationship);
+UNIQUE
+ UR1: SELF\product_definition_relationship.id, 
+      SELF\product_definition_relationship.relating_product_definition, 
+      SELF\product_definition_relationship.related_product_definition;
+ WHERE
+	WR1 : acyclic_product_definition_relationship
+         (SELF,
+         [SELF\product_definition_relationship.related_product_definition],
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_USAGE');
+END_ENTITY;
+
+
+ENTITY product_definition_with_associated_documents
+	SUBTYPE OF (product_definition);
+	documentation_ids : SET [1:?] OF document;
+END_ENTITY;
+
+
+ENTITY product_identification
+	SUBTYPE OF (configuration_item, characterized_object);
+	SELF\configuration_item.item_concept : product_class;
+WHERE
+	WR1 : SIZEOF(QUERY 
+		( cd <* USEDIN ( SELF ,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONFIGURATION_DESIGN.CONFIGURATION' ) 
+		|
+     	( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'PRODUCT_DEFINITION_FORMATION' IN TYPEOF ( cd. design ) ) 
+     	AND 
+    	( SIZEOF ( QUERY 
+    	( 
+    	prpc <* USEDIN ( cd. design\product_definition_formation.of_product , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') 
+    	| 
+        prpc. name IN ['part' , 'raw material' , 'tool'] ) ) >0
+     	) 
+     	) 
+     	) <=1;
+	WR2 : NOT ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'CONFIGURABLE_ITEM' IN TYPEOF( SELF ) ) 
+			XOR ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'PRODUCT_SPECIFICATION' IN TYPEOF ( SELF ) );
+END_ENTITY;
+
+
+ENTITY product_material_composition_relationship
+	SUBTYPE OF (product_definition_relationship);
+	class : label;
+	constituent_amount : SET [1:?] OF characterized_product_composition_value;
+	composition_basis : label;
+	determination_method : text;
+END_ENTITY;
+
+
+ENTITY product_related_product_category
+	SUBTYPE OF (product_category);
+	products : SET [1:?] OF product;
+END_ENTITY;
+
+
+ENTITY product_specification
+	SUBTYPE OF (product_identification, configurable_item);
+END_ENTITY;
+
+
+ENTITY projected_zone_definition
+	SUBTYPE OF (tolerance_zone_definition);
+	projection_end : shape_aspect;
+	projected_length : measure_with_unit;
+WHERE
+	WR1 : ('NUMBER' IN TYPEOF
+       (projected_length\measure_with_unit.value_component)) AND
+       (projected_length\measure_with_unit.value_component > 0.0);
+	WR2 : (derive_dimensional_exponents
+       (projected_length\measure_with_unit.unit_component)=
+        dimensional_exponents(1,0,0,0,0,0,0));
+END_ENTITY;
+
+
+ENTITY projection_curve
+	SUBTYPE OF (annotation_curve_occurrence);
+END_ENTITY;
+
+
+ENTITY projection_directed_callout
+	SUBTYPE OF (draughting_callout);
+WHERE
+	WR1 : SIZEOF(QUERY(p_1<*SELF\draughting_callout.contents | 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_CURVE' IN (TYPEOF(p_1))))=1;
+	WR2 : SIZEOF(SELF\draughting_callout.contents) >=2;
+END_ENTITY;
+
+
+ENTITY promissory_usage_occurrence
+	SUBTYPE OF (assembly_component_usage);
+END_ENTITY;
+
+
+ENTITY property_definition;
+	name : label;
+	description : OPTIONAL text;
+	definition : characterized_definition;
+DERIVE
+	id : identifier := get_id_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY property_definition_relationship;
+	name : label;
+	description : text;
+	relating_property_definition : property_definition;
+	related_property_definition : property_definition;
+END_ENTITY;
+
+
+ENTITY property_definition_representation;
+	definition : represented_definition;
+	used_representation : representation;
+DERIVE
+	description : text := get_description_value(SELF);
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY qualified_representation_item
+	SUBTYPE OF (representation_item);
+	qualifiers : SET [1:?] OF value_qualifier;
+WHERE
+	WR1 : SIZEOF(QUERY(temp <* qualifiers |
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRECISION_QUALIFIER'
+             IN TYPEOF(temp))) < 2;
+END_ENTITY;
+
+
+ENTITY qualitative_uncertainty
+	SUBTYPE OF (uncertainty_qualifier);
+	uncertainty_value : text;
+END_ENTITY;
+
+
+ENTITY quantified_assembly_component_usage
+	SUBTYPE OF (assembly_component_usage);
+	quantity : measure_with_unit;
+WHERE
+	WR1 : (NOT ('NUMBER' IN TYPEOF(quantity.value_component)))
+       OR (quantity.value_component > 0);
+END_ENTITY;
+
+
+ENTITY quasi_uniform_curve
+	SUBTYPE OF (b_spline_curve);
+END_ENTITY;
+
+
+ENTITY quasi_uniform_surface
+	SUBTYPE OF (b_spline_surface);
+END_ENTITY;
+
+
+ENTITY radioactivity_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RADIOACTIVITY_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY radioactivity_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.becquerel);
+END_ENTITY;
+
+
+ENTITY radius_dimension
+	SUBTYPE OF (dimension_curve_directed_callout);
+WHERE
+	WR1 : SIZEOF (QUERY (con <* SELF.contents |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_CURVE' IN TYPEOF (con)))<=1;
+END_ENTITY;
+
+
+ENTITY range_characteristic
+	SUBTYPE OF (representation, descriptive_representation_item);
+WHERE
+	WR1 : NOT(SELF\representation.name IN ['tolerance', 'minimum tolerance', 'maximum tolerance', 
+        'nominal tolerance', 'plus minus tolerance', 'symmetrical tolerance', 'statistical tolerance']);
+END_ENTITY;
+
+
+ENTITY ratio_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RATIO_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY ratio_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY rational_b_spline_curve
+	SUBTYPE OF (b_spline_curve);
+	weights_data : LIST [2:?] OF REAL;
+DERIVE
+	weights : ARRAY [0:upper_index_on_control_points] OF REAL := list_to_array(weights_data,0,
+                                      upper_index_on_control_points);
+WHERE
+	WR1 : SIZEOF(weights_data) = SIZEOF(SELF\b_spline_curve.
+                                           control_points_list);
+	WR2 : curve_weights_positive(SELF);
+END_ENTITY;
+
+
+ENTITY rational_b_spline_surface
+	SUBTYPE OF (b_spline_surface);
+	weights_data : LIST [2:?] OF LIST [2:?] OF REAL;
+DERIVE
+	weights : ARRAY [0:u_upper] OF ARRAY [0:v_upper] OF REAL := make_array_of_array(weights_data,0,u_upper,0,v_upper);
+WHERE
+	WR1 : (SIZEOF(weights_data) =
+                     SIZEOF(SELF\b_spline_surface.control_points_list))
+           AND (SIZEOF(weights_data[1]) =
+                  SIZEOF(SELF\b_spline_surface.control_points_list[1]));
+	WR2 : surface_weights_positive(SELF);
+END_ENTITY;
+
+
+ENTITY rational_representation_item
+	SUBTYPE OF (representation_item, slash_expression);
+WHERE
+	WR1 : SIZEOF( QUERY( operand <* SELF\binary_generic_expression.operands | 
+        NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INT_LITERAL' IN TYPEOF(operand)))) = 0;
+END_ENTITY;
+
+
+ENTITY real_literal
+	SUBTYPE OF (literal_number);
+	SELF\literal_number.the_value : REAL;
+END_ENTITY;
+
+
+ENTITY real_representation_item
+	SUBTYPE OF (representation_item, real_literal);
+END_ENTITY;
+
+
+ENTITY rectangular_composite_surface
+	SUBTYPE OF (bounded_surface);
+	segments : LIST [1:?] OF LIST [1:?] OF surface_patch;
+DERIVE
+	n_u : INTEGER := SIZEOF(segments);
+	n_v : INTEGER := SIZEOF(segments[1]);
+WHERE
+	WR1 : SIZEOF(QUERY (s <* segments | n_v <> SIZEOF (s))) = 0;
+	WR2 : constraints_rectangular_composite_surface(SELF);
+END_ENTITY;
+
+
+ENTITY rectangular_trimmed_surface
+	SUBTYPE OF (bounded_surface);
+	basis_surface : surface;
+	u1 : parameter_value;
+	u2 : parameter_value;
+	v1 : parameter_value;
+	v2 : parameter_value;
+	usense : BOOLEAN;
+	vsense : BOOLEAN;
+WHERE
+	WR1 : u1 <> u2;
+	WR2 : v1 <> v2;
+	WR3 : (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELEMENTARY_SURFACE' IN TYPEOF(basis_surface))
+       AND  (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE' IN TYPEOF(basis_surface)))) OR
+      ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_OF_REVOLUTION' IN TYPEOF(basis_surface))
+          OR (usense = (u2 > u1));
+	WR4 : (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SPHERICAL_SURFACE' IN TYPEOF(basis_surface))
+          OR
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TOROIDAL_SURFACE' IN TYPEOF(basis_surface)))
+          OR (vsense = (v2 > v1));
+END_ENTITY;
+
+
+ENTITY referenced_modified_datum
+	SUBTYPE OF (datum_reference);
+	modifier : limit_condition;
+END_ENTITY;
+
+
+ENTITY relative_event_occurrence
+	SUBTYPE OF (event_occurrence);
+	base_event : event_occurrence;
+	offset : time_measure_with_unit;
+END_ENTITY;
+
+
+ENTITY rep_item_group
+	SUBTYPE OF (group, representation_item);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRESENTATION_LAYER_ASSIGNMENT.' + 'ASSIGNED_ITEMS')) > 0;
+	WR2 : SIZEOF(QUERY(r <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION.' + 'ITEMS') | r.name = 'group representation')) > 0;
+	WR3 : SIZEOF(QUERY(ga <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GROUP_ASSIGNMENT.' + 'ASSIGNED_GROUP') | ga.role.name <> 'group membership')) = 0;
+	WR4 : SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_REPRESENTATION_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'TOPOLOGICAL_REPRESENTATION_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'MAPPED_ITEM','AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'STYLED_ITEM'] * TYPEOF(SELF)) = 1;
+END_ENTITY;
+
+
+ENTITY reparametrised_composite_curve_segment
+	SUBTYPE OF (composite_curve_segment);
+	param_length : parameter_value;
+WHERE
+	WR1 : param_length > 0.0;
+END_ENTITY;
+
+
+ENTITY representation;
+	name : label;
+	items : SET [1:?] OF representation_item;
+	context_of_items : representation_context;
+DERIVE
+	description : text := get_description_value (SELF);
+	id : identifier := get_id_value (SELF);
+WHERE
+	WR1 : SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'ID_ATTRIBUTE.IDENTIFIED_ITEM'))
+         <= 1;
+	WR2 : SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM'))
+         <= 1;
+END_ENTITY;
+
+
+ENTITY representation_context;
+	context_identifier : identifier;
+	context_type : text;
+INVERSE
+	representations_in_context: SET [1:?] OF representation FOR context_of_items;
+END_ENTITY;
+
+
+ENTITY representation_item
+	SUPERTYPE OF (ONEOF (binary_representation_item, compound_representation_item, mapped_item, value_representation_item, mapped_item, styled_item, boolean_representation_item, date_representation_item, date_time_representation_item, integer_representation_item, logical_representation_item, rational_representation_item, real_representation_item));
+	name : label;
+WHERE
+	WR1 : SIZEOF(using_representations(SELF)) > 0;
+END_ENTITY;
+
+
+ENTITY representation_item_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_representation_item : representation_item;
+	related_representation_item : representation_item;
+END_ENTITY;
+
+
+ENTITY representation_map;
+	mapping_origin : representation_item;
+	mapped_representation : representation;
+INVERSE
+	map_usage: SET [1:?] OF mapped_item FOR mapping_source;
+WHERE
+	WR1 : item_in_context(SELF.mapping_origin,
+        SELF.mapped_representation.context_of_items);
+END_ENTITY;
+
+
+ENTITY representation_relationship;
+	name : label;
+	description : OPTIONAL text;
+	rep_1 : representation;
+	rep_2 : representation;
+END_ENTITY;
+
+
+ENTITY representation_relationship_with_transformation
+	SUBTYPE OF (representation_relationship);
+	transformation_operator : transformation;
+WHERE
+	WR1 : SELF\representation_relationship.rep_1.context_of_items
+           :<>: SELF\representation_relationship.rep_2.context_of_items;
+END_ENTITY;
+
+
+ENTITY requirement_assigned_object
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF requirement_assigned_item;
+	SELF\group_assignment.assigned_group : requirement_assignment;
+END_ENTITY;
+
+
+ENTITY requirement_assignment
+	SUBTYPE OF (characterized_object, group);
+END_ENTITY;
+
+
+ENTITY requirement_source
+	SUBTYPE OF (group);
+END_ENTITY;
+
+
+ENTITY requirement_view_definition_relationship
+	SUBTYPE OF (product_definition_relationship);
+END_ENTITY;
+
+
+ENTITY resistance_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RESISTANCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY resistance_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.ohm);
+END_ENTITY;
+
+
+ENTITY revolved_area_solid
+	SUBTYPE OF (swept_area_solid);
+	axis : axis1_placement;
+	angle : plane_angle_measure;
+DERIVE
+	axis_line : line := representation_item('')||
+                    geometric_representation_item()|| curve()||
+                    line(axis.location, representation_item('')||
+                    geometric_representation_item()||
+                    vector(axis.z, 1.0));
+END_ENTITY;
+
+
+ENTITY revolved_face_solid
+	SUBTYPE OF (swept_face_solid);
+	axis : axis1_placement;
+	angle : plane_angle_measure;
+DERIVE
+	axis_line : line := representation_item('')||
+                    geometric_representation_item()|| curve()||
+                    line(axis.location, representation_item('')||
+                    geometric_representation_item()||
+                    vector(axis.z, 1.0));
+END_ENTITY;
+
+
+ENTITY revolved_face_solid_with_trim_conditions
+	SUBTYPE OF (revolved_face_solid);
+	first_trim_condition : trim_condition_select;
+	second_trim_condition : trim_condition_select;
+WHERE
+	WR1 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(first_trim_condition)) 
+         OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(second_trim_condition)));
+	WR2 : NOT((('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE_ANGLE_MEASURE' 
+         IN TYPEOF(first_trim_condition)) AND
+            ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE_ANGLE_MEASURE' 
+         IN TYPEOF(second_trim_condition))) AND
+         (first_trim_condition = second_trim_condition));
+END_ENTITY;
+
+
+ENTITY right_angular_wedge
+	SUBTYPE OF (geometric_representation_item);
+	position : axis2_placement_3d;
+	x : positive_length_measure;
+	y : positive_length_measure;
+	z : positive_length_measure;
+	ltx : length_measure;
+WHERE
+	WR1 : ((0.0 <= ltx) AND (ltx < x));
+END_ENTITY;
+
+
+ENTITY right_circular_cone
+	SUBTYPE OF (geometric_representation_item);
+	position : axis1_placement;
+	height : positive_length_measure;
+	radius : length_measure;
+	semi_angle : plane_angle_measure;
+WHERE
+	WR1 : radius >= 0.0;
+END_ENTITY;
+
+
+ENTITY right_circular_cylinder
+	SUBTYPE OF (geometric_representation_item);
+	position : axis1_placement;
+	height : positive_length_measure;
+	radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY right_to_usage_association
+	SUBTYPE OF (action_method_relationship);
+	SELF\action_method_relationship.related_method : information_right;
+	SELF\action_method_relationship.relating_method : information_usage_right;
+DERIVE
+	right_applied : information_right := SELF\action_method_relationship.related_method;
+	right_usage : information_usage_right := SELF\action_method_relationship.relating_method;
+END_ENTITY;
+
+
+ENTITY role_association;
+	role : object_role;
+	item_with_role : role_select;
+END_ENTITY;
+
+
+ENTITY roundness_tolerance
+	SUBTYPE OF (geometric_tolerance);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE' IN TYPEOF (SELF));
+END_ENTITY;
+
+
+ENTITY row_representation_item
+	SUBTYPE OF (compound_representation_item);
+	SELF\compound_representation_item.item_element : list_representation_item;
+END_ENTITY;
+
+
+ENTITY row_value
+	SUBTYPE OF (compound_representation_item);
+END_ENTITY;
+
+
+ENTITY row_variable
+	SUBTYPE OF (abstract_variable);
+END_ENTITY;
+
+
+ENTITY rule_action
+	SUBTYPE OF (action);
+END_ENTITY;
+
+
+ENTITY rule_condition
+	SUBTYPE OF (atomic_formula);
+END_ENTITY;
+
+
+ENTITY rule_definition
+	SUBTYPE OF (rule_software_definition);
+END_ENTITY;
+
+
+ENTITY rule_set
+	SUBTYPE OF (rule_software_definition);
+END_ENTITY;
+
+
+ENTITY rule_set_group
+	SUBTYPE OF (rule_software_definition);
+END_ENTITY;
+
+
+ENTITY rule_software_definition
+	SUBTYPE OF (product_definition);
+END_ENTITY;
+
+
+ENTITY rule_superseded_assignment
+	SUBTYPE OF (action_assignment);
+	items : SET [1:?] OF rule_superseded_item;
+END_ENTITY;
+
+
+ENTITY rule_supersedence
+	SUBTYPE OF (rule_action);
+END_ENTITY;
+
+
+ENTITY ruled_surface_swept_area_solid
+	SUBTYPE OF (surface_curve_swept_area_solid);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_SURFACE' IN TYPEOF(SELF.reference_surface)) AND
+         (SELF.reference_surface\b_spline_surface.u_degree = 1);
+	WR2 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(SELF.directrix)) OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' IN TYPEOF(SELF.directrix\surface_curve.curve_3d))
+         AND
+         (SELF.directrix\surface_curve.curve_3d\b_spline_curve.degree =
+         SELF.reference_surface\b_spline_surface.v_degree));
+END_ENTITY;
+
+
+ENTITY runout_zone_definition
+	SUBTYPE OF (tolerance_zone_definition);
+	orientation : runout_zone_orientation;
+END_ENTITY;
+
+
+ENTITY runout_zone_orientation;
+	angle : measure_with_unit;
+END_ENTITY;
+
+
+ENTITY runout_zone_orientation_reference_direction
+	SUBTYPE OF (runout_zone_orientation);
+	orientation_defining_relationship : shape_aspect_relationship;
+END_ENTITY;
+
+
+ENTITY satisfied_requirement
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF product_definition;
+	SELF\group_assignment.assigned_group : satisfies_requirement;
+END_ENTITY;
+
+
+ENTITY satisfies_requirement
+	SUBTYPE OF (group);
+END_ENTITY;
+
+
+ENTITY satisfying_item
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF requirement_satisfaction_item;
+	SELF\group_assignment.assigned_group : satisfies_requirement;
+END_ENTITY;
+
+
+ENTITY scalar_variable
+	SUBTYPE OF (abstract_variable);
+END_ENTITY;
+
+
+ENTITY scattering_parameter
+	SUBTYPE OF (polar_complex_number_literal);
+WHERE
+	WR1 : SIZEOF(TYPEOF(SELF) - (TYPEOF(SELF\polar_complex_number_literal ||
+       SELF\scattering_parameter))) = 0;
+END_ENTITY;
+
+
+ENTITY sculptured_solid
+	SUBTYPE OF (modified_solid);
+	sculpturing_element : generalized_surface_select;
+	positive_side : BOOLEAN;
+END_ENTITY;
+
+
+ENTITY seam_curve
+	SUBTYPE OF (surface_curve);
+WHERE
+	WR1 : SIZEOF(SELF\surface_curve.associated_geometry) = 2;
+	WR2 : associated_surface(SELF\surface_curve.associated_geometry[1]) =
+           associated_surface(SELF\surface_curve.associated_geometry[2]);
+	WR3 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN
+           TYPEOF(SELF\surface_curve.associated_geometry[1]);
+	WR4 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN
+            TYPEOF(SELF\surface_curve.associated_geometry[2]);
+END_ENTITY;
+
+
+ENTITY security_classification;
+	name : label;
+	purpose : text;
+	security_level : security_classification_level;
+END_ENTITY;
+
+
+ENTITY security_classification_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_security_classification : security_classification;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY security_classification_level;
+	name : label;
+END_ENTITY;
+
+
+ENTITY serial_numbered_effectivity
+	SUBTYPE OF (effectivity);
+	effectivity_start_id : identifier;
+	effectivity_end_id : OPTIONAL identifier;
+END_ENTITY;
+
+
+ENTITY shape_aspect;
+	name : label;
+	description : OPTIONAL text;
+	of_shape : product_definition_shape;
+	product_definitional : LOGICAL;
+DERIVE
+	id : identifier := get_id_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY shape_aspect_associativity
+	SUBTYPE OF (shape_aspect_relationship);
+WHERE
+	WR1 : SELF.relating_shape_aspect.product_definitional;
+	WR2 : NOT (SELF.related_shape_aspect.product_definitional);
+END_ENTITY;
+
+
+ENTITY shape_aspect_deriving_relationship
+	SUBTYPE OF (shape_aspect_relationship);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DERIVED_SHAPE_ASPECT' IN
+TYPEOF
+            (SELF\SHAPE_ASPECT_RELATIONSHIP.RELATING_SHAPE_ASPECT);
+END_ENTITY;
+
+
+ENTITY shape_aspect_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_shape_aspect : shape_aspect;
+	related_shape_aspect : shape_aspect;
+DERIVE
+	id : identifier := get_id_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY shape_definition_representation
+	SUBTYPE OF (property_definition_representation);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_SHAPE' IN TYPEOF(SELF.definition)) OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_DEFINITION' IN TYPEOF(SELF.definition.definition));
+	WR2 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION' IN TYPEOF(SELF.used_representation);
+END_ENTITY;
+
+
+ENTITY shape_dimension_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF (QUERY (temp <* SELF\representation.items | 
+    NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' 
+        IN TYPEOF (temp)))) = 0;
+	WR2 : SIZEOF (SELF\representation.items) <= 3;
+	WR3 : SIZEOF (QUERY (pos_mri <* QUERY (real_mri <*
+        SELF\representation.items | 'REAL' IN TYPEOF
+        (real_mri\measure_with_unit.value_component) ) |        
+     NOT  (pos_mri\measure_with_unit.value_component > 0.0 ))) = 0;
+END_ENTITY;
+
+
+ENTITY shape_feature_definition
+	SUBTYPE OF (characterized_object);
+END_ENTITY;
+
+
+ENTITY shape_representation
+	SUBTYPE OF (representation);
+END_ENTITY;
+
+
+ENTITY shape_representation_relationship
+	SUBTYPE OF (representation_relationship);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION' IN (TYPEOF(SELF\representation_relationship.rep_1) + TYPEOF(SELF\representation_relationship.rep_2));
+END_ENTITY;
+
+
+ENTITY shape_representation_with_parameters
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF( QUERY( i <* SELF.items | SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLACEMENT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DESCRIPTIVE_REPRESENTATION_ITEM'] * TYPEOF(i)) = 1 )) = SIZEOF(SELF.items);
+END_ENTITY;
+
+
+ENTITY shell_based_surface_model
+	SUBTYPE OF (geometric_representation_item);
+	sbsm_boundary : SET [1:?] OF shell;
+WHERE
+	WR1 : constraints_geometry_shell_based_surface_model(SELF);
+END_ENTITY;
+
+
+ENTITY shell_based_wireframe_model
+	SUBTYPE OF (geometric_representation_item);
+	sbwm_boundary : SET [1:?] OF shell;
+WHERE
+	WR1 : constraints_geometry_shell_based_wireframe_model(SELF);
+END_ENTITY;
+
+
+ENTITY shell_based_wireframe_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF ( 
+QUERY ( it <* SELF.items| NOT ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D' ] * TYPEOF (it)) = 1) )) = 0;
+	WR2 : SIZEOF ( 
+QUERY ( it <* SELF.items| ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' ] * TYPEOF (it)) = 1) )) >= 1;
+	WR3 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( ws <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN TYPEOF (sb)) )| NOT ( SIZEOF ( 
+QUERY ( eloop <* 
+QUERY ( wsb <* ws\wire_shell.wire_shell_extent| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (wsb)) )| NOT ( SIZEOF ( 
+QUERY ( el <* eloop\path.edge_list| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN TYPEOF (el.edge_element)) )) = 0) )) = 0) )) = 0) )) = 0;
+	WR4 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( ws <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN TYPEOF (sb)) )| NOT ( SIZEOF ( 
+QUERY ( eloop <* 
+QUERY ( wsb <* ws\wire_shell.wire_shell_extent| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (wsb)) )| NOT ( SIZEOF ( 
+QUERY ( pline_el <* 
+QUERY ( el <* eloop\path.edge_list| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF (el.edge_element\edge_curve.edge_geometry)) )| NOT ( SIZEOF (pline_el.edge_element\edge_curve.edge_geometry\polyline.points) > 2) )) = 0) )) = 0) )) = 0) )) = 0;
+	WR5 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( ws <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN TYPEOF (sb)) )| NOT ( SIZEOF ( 
+QUERY ( eloop <* 
+QUERY ( wsb <* ws\wire_shell.wire_shell_extent| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (wsb)) )| NOT ( SIZEOF ( 
+QUERY ( el <* eloop\path.edge_list| NOT valid_wireframe_edge_curve(el.edge_element\edge_curve.edge_geometry) )) = 0) )) = 0) )) = 0) )) = 0;
+	WR6 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( ws <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN TYPEOF (sb)) )| NOT ( SIZEOF ( 
+QUERY ( eloop <* 
+QUERY ( wsb <* ws\wire_shell.wire_shell_extent| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (wsb)) )| NOT ( SIZEOF ( 
+QUERY ( el <* eloop\path.edge_list| NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (el.edge_element.edge_start)) AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (el.edge_element.edge_end))) )) = 0) )) = 0) )) = 0) )) = 0;
+	WR7 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( ws <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN TYPEOF (sb)) )| NOT ( SIZEOF ( 
+QUERY ( eloop <* 
+QUERY ( wsb <* ws\wire_shell.wire_shell_extent| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (wsb)) )| NOT ( SIZEOF ( 
+QUERY ( el <* eloop\path.edge_list| NOT (valid_wireframe_vertex_point(el.edge_element.edge_start\vertex_point.vertex_geometry) AND valid_wireframe_vertex_point(el.edge_element.edge_end\vertex_point.vertex_geometry)) )) = 0) )) = 0) )) = 0) )) = 0;
+	WR8 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( ws <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN TYPEOF (sb)) )| NOT ( SIZEOF ( 
+QUERY ( vloop <* 
+QUERY ( wsb <* ws\wire_shell.wire_shell_extent| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF (wsb)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (vloop\vertex_loop.loop_vertex)) )) = 0) )) = 0) )) = 0;
+	WR9 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( ws <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN TYPEOF (sb)) )| NOT ( SIZEOF ( 
+QUERY ( vloop <* 
+QUERY ( wsb <* ws\wire_shell.wire_shell_extent| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF (wsb)) )| NOT valid_wireframe_vertex_point(vloop\vertex_loop.loop_vertex\vertex_point.vertex_geometry) )) = 0) )) = 0) )) = 0;
+	WR10 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( vs <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_SHELL' IN TYPEOF (sb)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (vs\vertex_shell.vertex_shell_extent.loop_vertex)) )) = 0) )) = 0;
+	WR11 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( vs <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_SHELL' IN TYPEOF (sb)) )| NOT valid_wireframe_vertex_point(vs\vertex_shell.vertex_shell_extent.loop_vertex\vertex_point.vertex_geometry) )) = 0) )) = 0;
+	WR12 : SIZEOF ( 
+QUERY ( mi <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'SHELL_BASED_WIREFRAME_SHAPE_REPRESENTATION' IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation)) )) = 0;
+	WR13 : SELF.context_of_items\geometric_representation_context.coordinate_space_dimension = 3;
+END_ENTITY;
+
+
+ENTITY shelled_solid
+	SUPERTYPE OF (ONEOF (double_offset_shelled_solid, complex_shelled_solid))
+	SUBTYPE OF (modified_solid);
+	deleted_face_set : SET [1:?] OF face_surface;
+	thickness : length_measure;
+WHERE
+	WR1 : thickness <> 0;
+END_ENTITY;
+
+
+ENTITY si_absorbed_dose_unit
+	SUBTYPE OF (absorbed_dose_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.gray;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_capacitance_unit
+	SUBTYPE OF (capacitance_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.farad;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_conductance_unit
+	SUBTYPE OF (conductance_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.siemens;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_dose_equivalent_unit
+	SUBTYPE OF (dose_equivalent_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.sievert;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_electric_charge_unit
+	SUBTYPE OF (electric_charge_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.coulomb;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_electric_potential_unit
+	SUBTYPE OF (electric_potential_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.volt;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_energy_unit
+	SUBTYPE OF (energy_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.joule;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_force_unit
+	SUBTYPE OF (force_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.newton;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_frequency_unit
+	SUBTYPE OF (frequency_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.hertz;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_illuminance_unit
+	SUBTYPE OF (illuminance_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.lux;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_inductance_unit
+	SUBTYPE OF (inductance_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.henry;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_magnetic_flux_density_unit
+	SUBTYPE OF (magnetic_flux_density_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.tesla;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_magnetic_flux_unit
+	SUBTYPE OF (magnetic_flux_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.weber;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_power_unit
+	SUBTYPE OF (power_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.watt;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_pressure_unit
+	SUBTYPE OF (pressure_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.pascal;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_radioactivity_unit
+	SUBTYPE OF (radioactivity_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.becquerel;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_resistance_unit
+	SUBTYPE OF (resistance_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.ohm;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_unit
+	SUBTYPE OF (named_unit);
+	prefix : OPTIONAL si_prefix;
+	name : si_unit_name;
+DERIVE
+	SELF\named_unit.dimensions : dimensional_exponents := dimensions_for_si_unit(name);
+WHERE
+	WR1 : NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MASS_UNIT' IN TYPEOF(SELF)) AND
+             (SIZEOF(USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DERIVED_UNIT_ELEMENT.UNIT')) > 0)) OR
+            (prefix = si_prefix.kilo);
+END_ENTITY;
+
+
+ENTITY simple_boolean_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (boolean_expression, simple_generic_expression);
+END_ENTITY;
+
+
+ENTITY simple_clause
+	SUBTYPE OF (compound_representation_item);
+END_ENTITY;
+
+
+ENTITY simple_generic_expression
+	ABSTRACT SUPERTYPE OF (ONEOF (generic_literal, generic_variable))
+	SUBTYPE OF (generic_expression);
+END_ENTITY;
+
+
+ENTITY simple_numeric_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (numeric_expression, simple_generic_expression);
+END_ENTITY;
+
+
+ENTITY slash_expression
+	SUBTYPE OF (binary_numeric_expression);
+END_ENTITY;
+
+
+ENTITY smeared_material_definition
+	SUBTYPE OF (zone_structural_makeup);
+END_ENTITY;
+
+
+ENTITY solid_angle_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_ANGLE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY solid_angle_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY solid_curve_font
+	SUBTYPE OF (pre_defined_curve_font);
+END_ENTITY;
+
+
+ENTITY solid_model
+	SUPERTYPE OF (ONEOF (csg_solid, manifold_solid_brep, swept_face_solid, swept_area_solid, swept_disk_solid, solid_replica))
+	SUBTYPE OF (geometric_representation_item);
+END_ENTITY;
+
+
+ENTITY solid_replica
+	SUBTYPE OF (solid_model);
+	parent_solid : solid_model;
+	transformation : cartesian_transformation_operator_3d;
+WHERE
+	WR1 : acyclic_solid_replica(SELF, parent_solid);
+	WR2 : parent_solid\geometric_representation_item.dim = 3;
+END_ENTITY;
+
+
+ENTITY solid_with_angle_based_chamfer
+	SUBTYPE OF (solid_with_chamfered_edges);
+	offset_distance : positive_length_measure;
+	left_offset : BOOLEAN;
+	offset_angle : positive_plane_angle_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_chamfered_edges
+	ABSTRACT SUPERTYPE OF (ONEOF (solid_with_single_offset_chamfer, solid_with_double_offset_chamfer, solid_with_angle_based_chamfer))
+	SUBTYPE OF (edge_blended_solid);
+END_ENTITY;
+
+
+ENTITY solid_with_circular_pattern
+	SUPERTYPE OF (solid_with_incomplete_circular_pattern)
+	SUBTYPE OF (solid_with_shape_element_pattern);
+	replicate_count : positive_integer;
+	angular_spacing : plane_angle_measure;
+	radial_alignment : BOOLEAN;
+	reference_point : point;
+END_ENTITY;
+
+
+ENTITY solid_with_circular_pocket
+	SUBTYPE OF (solid_with_pocket);
+	pocket_radius : positive_length_measure;
+WHERE
+	WR1 : SELF\solid_with_pocket.floor_blend_radius <= pocket_radius;
+END_ENTITY;
+
+
+ENTITY solid_with_circular_protrusion
+	SUBTYPE OF (solid_with_protrusion);
+	protrusion_radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_conical_bottom_round_hole
+	SUBTYPE OF (solid_with_stepped_round_hole);
+	semi_apex_angle : positive_plane_angle_measure;
+	tip_radius : non_negative_length_measure;
+WHERE
+	WR1 : tip_radius < 
+          SELF\solid_with_stepped_round_hole.segment_radii[segments];
+END_ENTITY;
+
+
+ENTITY solid_with_constant_radius_edge_blend
+	SUBTYPE OF (edge_blended_solid);
+	radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_curved_slot
+	SUBTYPE OF (solid_with_slot);
+	slot_centreline : bounded_curve;
+END_ENTITY;
+
+
+ENTITY solid_with_depression
+	ABSTRACT SUPERTYPE OF ((solid_with_through_depression ANDOR ONEOF (solid_with_hole, solid_with_pocket, solid_with_slot, solid_with_groove)))
+	SUBTYPE OF (modified_solid_with_placed_configuration);
+	depth : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_double_offset_chamfer
+	SUBTYPE OF (solid_with_chamfered_edges);
+	left_offset_distance : positive_length_measure;
+	right_offset_distance : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_flat_bottom_round_hole
+	SUBTYPE OF (solid_with_stepped_round_hole);
+	fillet_radius : non_negative_length_measure;
+WHERE
+	WR1 : fillet_radius < 
+          SELF\solid_with_stepped_round_hole.segment_radii[segments];
+END_ENTITY;
+
+
+ENTITY solid_with_general_pocket
+	SUBTYPE OF (solid_with_pocket);
+	profile : positioned_sketch;
+	reference_point : point;
+WHERE
+	WR1 : SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_BOUNDED_SURFACE',
+    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE'] * TYPEOF(profile.sketch_basis)) = 1;
+	WR2 : profile IN using_items(reference_point,[]);
+END_ENTITY;
+
+
+ENTITY solid_with_general_protrusion
+	SUBTYPE OF (solid_with_protrusion);
+	profile : positioned_sketch;
+	reference_point : point;
+WHERE
+	WR1 : SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_BOUNDED_SURFACE',
+    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE'] * TYPEOF(profile.sketch_basis)) = 1;
+	WR2 : profile IN using_items(reference_point,[]);
+END_ENTITY;
+
+
+ENTITY solid_with_groove
+	SUBTYPE OF (solid_with_depression);
+	groove_radius : positive_length_measure;
+	groove_width : positive_length_measure;
+	draft_angle : plane_angle_measure;
+	floor_fillet_radius : non_negative_length_measure;
+	external_groove : BOOLEAN;
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_THROUGH_DEPRESSION'
+         IN TYPEOF(SELF));
+END_ENTITY;
+
+
+ENTITY solid_with_hole
+	ABSTRACT SUPERTYPE OF (solid_with_stepped_round_hole)
+	SUBTYPE OF (solid_with_depression);
+END_ENTITY;
+
+
+ENTITY solid_with_incomplete_circular_pattern
+	SUBTYPE OF (solid_with_circular_pattern);
+	omitted_instances : SET [1:?] OF positive_integer;
+WHERE
+	WR1 : SIZEOF(omitted_instances) <
+         SELF\solid_with_circular_pattern.replicate_count;
+	WR2 : SIZEOF(QUERY(q <* omitted_instances | q > 
+         SELF\solid_with_circular_pattern.replicate_count)) = 0;
+END_ENTITY;
+
+
+ENTITY solid_with_incomplete_rectangular_pattern
+	SUBTYPE OF (solid_with_rectangular_pattern);
+	omitted_instances : SET [1:?] OF LIST [2:2] OF positive_integer;
+WHERE
+	WR1 : NOT([1,1] IN omitted_instances);
+	WR2 : SIZEOF(omitted_instances) <
+         ((SELF\solid_with_rectangular_pattern.row_count *
+           SELF\solid_with_rectangular_pattern.column_count) - 1);
+	WR3 : SIZEOF(QUERY(q <* omitted_instances |
+         ((q[1] > SELF\solid_with_rectangular_pattern.row_count) OR
+          (q[2] > SELF\solid_with_rectangular_pattern.column_count)))) = 0;
+END_ENTITY;
+
+
+ENTITY solid_with_pocket
+	ABSTRACT SUPERTYPE OF (ONEOF (solid_with_rectangular_pocket, solid_with_circular_pocket, solid_with_general_pocket))
+	SUBTYPE OF (solid_with_depression);
+	floor_blend_radius : non_negative_length_measure;
+	draft_angle : plane_angle_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_protrusion
+	ABSTRACT SUPERTYPE OF (ONEOF (solid_with_circular_protrusion, solid_with_rectangular_protrusion, solid_with_general_protrusion))
+	SUBTYPE OF (modified_solid_with_placed_configuration);
+	protrusion_height : positive_length_measure;
+	protrusion_draft_angle : plane_angle_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_rectangular_pattern
+	SUPERTYPE OF (solid_with_incomplete_rectangular_pattern)
+	SUBTYPE OF (solid_with_shape_element_pattern);
+	row_count : positive_integer;
+	column_count : positive_integer;
+	row_spacing : length_measure;
+	column_spacing : length_measure;
+WHERE
+	WR1 : (row_count * column_count) > 1;
+END_ENTITY;
+
+
+ENTITY solid_with_rectangular_pocket
+	SUBTYPE OF (solid_with_pocket);
+	pocket_length : positive_length_measure;
+	pocket_width : positive_length_measure;
+	corner_radius : non_negative_length_measure;
+WHERE
+	WR1 : (corner_radius < pocket_width/2) 
+         AND (corner_radius < pocket_length/2);
+END_ENTITY;
+
+
+ENTITY solid_with_rectangular_protrusion
+	SUBTYPE OF (solid_with_protrusion);
+	protrusion_length : positive_length_measure;
+	protrusion_width : positive_length_measure;
+	protrusion_corner_radius : non_negative_length_measure;
+WHERE
+	WR1 : (protrusion_corner_radius <= protrusion_width/2) 
+         AND (protrusion_corner_radius <= protrusion_length/2);
+END_ENTITY;
+
+
+ENTITY solid_with_shape_element_pattern
+	ABSTRACT SUPERTYPE OF (ONEOF (solid_with_circular_pattern, solid_with_rectangular_pattern))
+	SUBTYPE OF (modified_solid_with_placed_configuration);
+	replicated_element : modified_solid_with_placed_configuration;
+END_ENTITY;
+
+
+ENTITY solid_with_single_offset_chamfer
+	SUBTYPE OF (solid_with_chamfered_edges);
+	offset_distance : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_slot
+	ABSTRACT SUPERTYPE OF ((ONEOF (solid_with_trapezoidal_section_slot, solid_with_tee_section_slot) AND ONEOF (solid_with_straight_slot, solid_with_curved_slot)))
+	SUBTYPE OF (solid_with_depression);
+	slot_width : positive_length_measure;
+	closed_ends : LIST [2:2] OF LOGICAL;
+	end_exit_faces : LIST [2:2] OF SET [0:?] OF face_surface;
+WHERE
+	WR1 : NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_THROUGH_DEPRESSION' IN
+         TYPEOF(SELF)) AND (closed_ends = [FALSE,FALSE]));
+	WR2 : NOT(((closed_ends[1] = TRUE) AND (SIZEOF(end_exit_faces[1]) <> 0))
+         OR ((closed_ends[2] = TRUE) AND (SIZEOF(end_exit_faces[2]) <> 0)));
+END_ENTITY;
+
+
+ENTITY solid_with_spherical_bottom_round_hole
+	SUBTYPE OF (solid_with_stepped_round_hole);
+	sphere_radius : positive_length_measure;
+WHERE
+	WR1 : sphere_radius >= 
+          SELF\solid_with_stepped_round_hole.segment_radii[segments];
+END_ENTITY;
+
+
+ENTITY solid_with_stepped_round_hole
+	SUPERTYPE OF ((solid_with_stepped_round_hole_and_conical_transitions ANDOR ONEOF (solid_with_flat_bottom_round_hole, solid_with_conical_bottom_round_hole, solid_with_spherical_bottom_round_hole)))
+	SUBTYPE OF (solid_with_hole);
+	segments : positive_integer;
+	segment_radii : LIST [1:segments] OF positive_length_measure;
+	segment_depths : LIST [1:segments] OF positive_length_measure;
+DERIVE
+	SELF\solid_with_depression.depth : positive_length_measure := compute_total_depth(SELF);
+WHERE
+	WR1 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_THROUGH_DEPRESSION'
+       IN TYPEOF(SELF)) AND (SIZEOF(TYPEOF(SELF) *
+       ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_FLAT_BOTTOM_ROUND_HOLE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_SPHERICAL_BOTTOM_ROUND_HOLE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_FLAT_BOTTOM_ROUND_HOLE']) 
+       <> 0));
+END_ENTITY;
+
+
+ENTITY solid_with_stepped_round_hole_and_conical_transitions
+	SUBTYPE OF (solid_with_stepped_round_hole);
+	conical_transitions : SET [1:?] OF conical_stepped_hole_transition;
+WHERE
+	WR1 : SIZEOF (conical_transitions) <= 
+         (SELF\solid_with_stepped_round_hole.segments + 1);
+	WR2 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_THROUGH_DEPRESSION'
+         IN TYPEOF(SELF)) XOR (SIZEOF(conical_transitions) <= 
+         SELF\solid_with_stepped_round_hole.segments);
+	WR3 : validate_countersink_radii(SELF);
+END_ENTITY;
+
+
+ENTITY solid_with_straight_slot
+	SUBTYPE OF (solid_with_slot);
+	slot_length : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_tee_section_slot
+	SUBTYPE OF (solid_with_slot);
+	tee_section_width : positive_length_measure;
+	collar_depth : positive_length_measure;
+WHERE
+	WR1 : collar_depth < SELF\solid_with_depression.depth;
+	WR2 : tee_section_width > SELF\solid_with_slot.slot_width;
+END_ENTITY;
+
+
+ENTITY solid_with_through_depression
+	SUBTYPE OF (solid_with_depression);
+	exit_faces : SET [1:?] OF face_surface;
+WHERE
+	WR1 : SIZEOF(TYPEOF(SELF) *
+         ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_HOLE',
+          'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_POCKET',
+          'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_SLOT']) = 1;
+END_ENTITY;
+
+
+ENTITY solid_with_trapezoidal_section_slot
+	SUBTYPE OF (solid_with_slot);
+	draft_angle : plane_angle_measure;
+	floor_fillet_radius : non_negative_length_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_variable_radius_edge_blend
+	SUBTYPE OF (edge_blended_solid, track_blended_solid);
+	point_list : LIST [2:?] OF point;
+	radius_list : LIST [2:?] OF positive_length_measure;
+	edge_function_list : LIST [1:?] OF blend_radius_variation_type;
+WHERE
+	WR1 : SIZEOF(point_list) = SIZEOF(radius_list);
+	WR2 : SIZEOF(edge_function_list) = SIZEOF(radius_list) - 1;
+	WR3 : NOT((point_list[1] = point_list[HIINDEX(point_list)]) AND NOT 
+         (radius_list[1] = radius_list[HIINDEX(radius_list)]));
+END_ENTITY;
+
+
+ENTITY source_for_requirement
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF requirement_source_item;
+	SELF\group_assignment.assigned_group : requirement_source;
+END_ENTITY;
+
+
+ENTITY sourced_requirement
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF product_definition;
+	SELF\group_assignment.assigned_group : requirement_source;
+END_ENTITY;
+
+
+ENTITY specification_definition
+	SUBTYPE OF (product_definition);
+END_ENTITY;
+
+
+ENTITY specified_higher_usage_occurrence
+	SUBTYPE OF (assembly_component_usage);
+	upper_usage : assembly_component_usage;
+	next_usage : next_assembly_usage_occurrence;
+UNIQUE
+	UR1 : upper_usage, next_usage;
+WHERE
+	WR1 : SELF :<>: upper_usage;
+	WR2 : SELF\product_definition_relationship.relating_product_definition
+       :=: upper_usage.relating_product_definition;
+	WR3 : SELF\product_definition_relationship.related_product_definition
+       :=: next_usage.related_product_definition;
+	WR4 : (upper_usage.related_product_definition :=:
+       next_usage.relating_product_definition) OR
+       (SIZEOF (QUERY (pdr <* USEDIN (upper_usage.related_product_definition,
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_RELATIONSHIP.' +
+       'RELATED_PRODUCT_DEFINITION') |
+        pdr.relating_product_definition :=: 
+        next_usage.relating_product_definition)) = 1);
+	WR5 : SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NEXT_ASSEMBLY_USAGE_OCCURRENCE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SPECIFIED_HIGHER_USAGE_OCCURRENCE']
+       * TYPEOF(upper_usage)) = 1;
+END_ENTITY;
+
+
+ENTITY sphere
+	SUBTYPE OF (geometric_representation_item);
+	radius : positive_length_measure;
+	centre : point;
+END_ENTITY;
+
+
+ENTITY spherical_surface
+	SUBTYPE OF (elementary_surface);
+	radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY standard_uncertainty
+	SUPERTYPE OF (expanded_uncertainty)
+	SUBTYPE OF (uncertainty_qualifier);
+	uncertainty_value : REAL;
+END_ENTITY;
+
+
+ENTITY start_request
+	SUBTYPE OF (action_request_assignment);
+	items : SET [1:?] OF start_request_item;
+END_ENTITY;
+
+
+ENTITY start_work
+	SUBTYPE OF (action_assignment);
+	items : SET [1:?] OF work_item;
+END_ENTITY;
+
+
+ENTITY straightness_tolerance
+	SUBTYPE OF (geometric_tolerance);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE' IN TYPEOF (SELF));
+END_ENTITY;
+
+
+ENTITY structured_dimension_callout
+	SUBTYPE OF (draughting_callout);
+WHERE
+	WR1 : SIZEOF (TYPEOF (SELF) *
+       ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DATUM_FEATURE_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DATUM_TARGET_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRICAL_TOLERANCE_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_DIRECTED_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_DIRECTED_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE_DIRECTED_CALLOUT']) = 0;
+	WR2 : SIZEOF (QUERY (ato <* QUERY (con <* SELF.contents |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (con))) |
+         NOT (ato.name IN
+             ['dimension value', 'tolerance value', 'unit text',
+              'prefix text', 'suffix text']))) = 0;
+	WR3 : SIZEOF (QUERY (ato <* QUERY (con <* SELF.contents |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (con))) |
+         (ato.name = 'dimension value')
+       )) >= 1;
+	WR4 : SIZEOF (QUERY (dcr <* USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+         'DRAUGHTING_CALLOUT_RELATIONSHIP.' +
+         'RELATING_DRAUGHTING_CALLOUT') |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+          'DIMENSION_CALLOUT_COMPONENT_RELATIONSHIP' IN TYPEOF (dcr)) AND 
+         (dcr.name = 'prefix') )) <= 1;
+	WR5 : SIZEOF (QUERY (dcr <* USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+         'DRAUGHTING_CALLOUT_RELATIONSHIP.' +
+         'RELATING_DRAUGHTING_CALLOUT') |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+          'DIMENSION_CALLOUT_COMPONENT_RELATIONSHIP' IN TYPEOF (dcr)) AND 
+         (dcr.name = 'suffix') )) <= 1;
+	WR6 : NOT((SIZEOF (QUERY (ato <* QUERY (con <* SELF.contents |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF(con)) ) |
+         (ato.name = 'prefix text')
+       )) > 0)) OR
+       (SIZEOF (QUERY (dcr <* USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                               'DRAUGHTING_CALLOUT_RELATIONSHIP.' +
+                               'RELATING_DRAUGHTING_CALLOUT') |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+          'DIMENSION_CALLOUT_COMPONENT_RELATIONSHIP' IN TYPEOF (dcr)) AND  
+         (dcr.name = 'prefix') )) = 1);
+	WR7 : NOT(SIZEOF (QUERY (ato <* QUERY (con <* SELF.contents |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF(con))) |
+         (ato.name = 'suffix text')
+       )) > 0) OR
+       (SIZEOF (QUERY (dcr <* USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                               'DRAUGHTING_CALLOUT_RELATIONSHIP.' +
+                               'RELATING_DRAUGHTING_CALLOUT') |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+          'DIMENSION_CALLOUT_COMPONENT_RELATIONSHIP' IN TYPEOF (dcr)) AND    
+            (dcr.name = 'suffix') )) = 1);
+END_ENTITY;
+
+
+ENTITY structured_text_composition
+	SUBTYPE OF (compound_representation_item);
+END_ENTITY;
+
+
+ENTITY structured_text_representation
+	SUBTYPE OF (representation);
+	SELF\representation.items : SET [1:?] OF string_representation_item_select;
+END_ENTITY;
+
+
+ENTITY styled_item
+	SUBTYPE OF (representation_item);
+	styles : SET [1:?] OF presentation_style_assignment;
+	item : representation_item;
+WHERE
+	WR1 : (SIZEOF(SELF.styles) = 1)
+               XOR
+         (SIZEOF(QUERY(pres_style <* SELF.styles |
+         NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+              'PRESENTATION_STYLE_BY_CONTEXT' IN
+         TYPEOF(pres_style))
+         )) = 0);
+END_ENTITY;
+
+
+ENTITY subedge
+	SUBTYPE OF (edge);
+	parent_edge : edge;
+END_ENTITY;
+
+
+ENTITY subface
+	SUBTYPE OF (face);
+	parent_face : face;
+WHERE
+	WR1 : NOT (mixed_loop_type_set(list_to_set(list_face_loops(SELF)) +
+              list_to_set(list_face_loops(parent_face))));
+END_ENTITY;
+
+
+ENTITY supplied_part_relationship
+	SUBTYPE OF (product_definition_relationship);
+END_ENTITY;
+
+
+ENTITY surface
+	SUPERTYPE OF (ONEOF (elementary_surface, swept_surface, bounded_surface, offset_surface, surface_replica))
+	SUBTYPE OF (geometric_representation_item);
+END_ENTITY;
+
+
+ENTITY surface_condition_callout
+	SUBTYPE OF (draughting_callout);
+WHERE
+	WR1 : SIZEOF ( QUERY ( c <* SELF.contents | SIZEOF (
+         ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'ANNOTATION_CURVE_OCCURRENCE' ,
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'ANNOTATION_SYMBOL_OCCURRENCE' ,
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'ANNOTATION_TEXT_OCCURRENCE']* TYPEOF
+         ( c ) ) <>1 ) ) =0;
+END_ENTITY;
+
+
+ENTITY surface_curve
+	SUPERTYPE OF ((ONEOF (intersection_curve, seam_curve) ANDOR bounded_surface_curve))
+	SUBTYPE OF (curve);
+	curve_3d : curve;
+	associated_geometry : LIST [1:2] OF pcurve_or_surface;
+	master_representation : preferred_surface_curve_representation;
+DERIVE
+	basis_surface : SET [1:2] OF surface := get_basis_surface(SELF);
+WHERE
+	WR1 : curve_3d.dim = 3;
+	WR2 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(associated_geometry[1])) OR
+                        (master_representation <> pcurve_s1);
+	WR3 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(associated_geometry[2])) OR
+                        (master_representation <> pcurve_s2);
+	WR4 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(curve_3d));
+END_ENTITY;
+
+
+ENTITY surface_curve_swept_area_solid
+	SUBTYPE OF (swept_area_solid);
+	directrix : curve;
+	start_param : REAL;
+	end_param : REAL;
+	reference_surface : surface;
+WHERE
+	WR1 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN TYPEOF(directrix))) OR
+          (reference_surface IN (directrix\surface_curve.basis_surface));
+END_ENTITY;
+
+
+ENTITY surface_of_linear_extrusion
+	SUBTYPE OF (swept_surface);
+	extrusion_axis : vector;
+END_ENTITY;
+
+
+ENTITY surface_of_revolution
+	SUBTYPE OF (swept_surface);
+	axis_position : axis1_placement;
+DERIVE
+	axis_line : line := representation_item('')||
+                     geometric_representation_item()|| curve()||
+                     line(axis_position.location, representation_item('')||
+                     geometric_representation_item()||
+                     vector(axis_position.z, 1.0));
+END_ENTITY;
+
+
+ENTITY surface_patch
+	SUBTYPE OF (founded_item);
+	parent_surface : bounded_surface;
+	u_transition : transition_code;
+	v_transition : transition_code;
+	u_sense : BOOLEAN;
+	v_sense : BOOLEAN;
+INVERSE
+	using_surfaces: BAG [1:?] OF rectangular_composite_surface FOR segments;
+WHERE
+	WR1 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_BOUNDED_SURFACE' 
+                 IN TYPEOF(parent_surface)));
+END_ENTITY;
+
+
+ENTITY surface_profile_tolerance
+	SUBTYPE OF (geometric_tolerance);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE' IN TYPEOF (SELF)) OR ( SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 3);
+END_ENTITY;
+
+
+ENTITY surface_rendering_properties;
+	rendered_colour : colour;
+END_ENTITY;
+
+
+ENTITY surface_replica
+	SUBTYPE OF (surface);
+	parent_surface : surface;
+	transformation : cartesian_transformation_operator_3d;
+WHERE
+	WR1 : acyclic_surface_replica(SELF, parent_surface);
+END_ENTITY;
+
+
+ENTITY surface_side_style
+	SUBTYPE OF (founded_item);
+	name : label;
+	styles : SET [1:7] OF surface_style_element_select;
+WHERE
+	WR1 : SIZEOF(QUERY( style1 <* SELF.styles |
+           SIZEOF(QUERY( style2 <* SELF.styles - style1 |
+           TYPEOF(style1) = TYPEOF(style2)
+           )) > 0
+           )) = 0;
+END_ENTITY;
+
+
+ENTITY surface_style_boundary
+	SUBTYPE OF (founded_item);
+	style_of_boundary : curve_or_render;
+END_ENTITY;
+
+
+ENTITY surface_style_control_grid
+	SUBTYPE OF (founded_item);
+	style_of_control_grid : curve_or_render;
+END_ENTITY;
+
+
+ENTITY surface_style_fill_area
+	SUBTYPE OF (founded_item);
+	fill_area : fill_area_style;
+END_ENTITY;
+
+
+ENTITY surface_style_parameter_line
+	SUBTYPE OF (founded_item);
+	style_of_parameter_lines : curve_or_render;
+	direction_counts : SET [1:2] OF direction_count_select;
+WHERE
+	WR1 : (HIINDEX(SELF.direction_counts) = 1)
+                        XOR
+         (TYPEOF(SELF.direction_counts[1]) <>
+          TYPEOF(SELF.direction_counts[2]));
+END_ENTITY;
+
+
+ENTITY surface_style_reflectance_ambient;
+	ambient_reflectance : REAL;
+END_ENTITY;
+
+
+ENTITY surface_style_reflectance_ambient_diffuse
+	SUBTYPE OF (surface_style_reflectance_ambient);
+	diffuse_reflectance : REAL;
+END_ENTITY;
+
+
+ENTITY surface_style_reflectance_ambient_diffuse_specular
+	SUBTYPE OF (surface_style_reflectance_ambient_diffuse);
+	specular_reflectance : REAL;
+	specular_exponent : REAL;
+	specular_colour : colour;
+END_ENTITY;
+
+
+ENTITY surface_style_rendering;
+	rendering_method : shading_surface_method;
+	surface_colour : colour;
+END_ENTITY;
+
+
+ENTITY surface_style_rendering_with_properties
+	SUBTYPE OF (surface_style_rendering);
+	properties : SET [1:2] OF rendering_properties_select;
+WHERE
+	WR1 : (HIINDEX(SELF.properties) = 1)
+                   XOR
+         (TYPEOF(SELF.properties[1]) <> TYPEOF(SELF.properties[2]));
+END_ENTITY;
+
+
+ENTITY surface_style_segmentation_curve
+	SUBTYPE OF (founded_item);
+	style_of_segmentation_curve : curve_or_render;
+END_ENTITY;
+
+
+ENTITY surface_style_silhouette
+	SUBTYPE OF (founded_item);
+	style_of_silhouette : curve_or_render;
+END_ENTITY;
+
+
+ENTITY surface_style_transparent;
+	transparency : REAL;
+WHERE
+	WR1 : {0.0 <= transparency <= 1.0};
+END_ENTITY;
+
+
+ENTITY surface_style_usage
+	SUBTYPE OF (founded_item);
+	side : surface_side;
+	style : surface_side_style_select;
+END_ENTITY;
+
+
+ENTITY surface_texture_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : SIZEOF ( QUERY ( i <* SELF.items | SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MEASURE_REPRESENTATION_ITEM' ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'VALUE_RANGE' , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DESCRIPTIVE_REPRESENTATION_ITEM']* TYPEOF ( i ) ) <>1 ) )
+        =0;
+	WR2 : ( SIZEOF ( QUERY ( i <* SELF.items | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF ( i ) ) ) =1 )
+        AND ( SIZEOF ( QUERY ( i <* SELF.items | (
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'DESCRIPTIVE_REPRESENTATION_ITEM' IN
+        TYPEOF ( i ) ) AND ( i.name = 'measuring method' ) ) ) =1 );
+	WR3 : SIZEOF ( QUERY ( i <* SELF.items | SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MEASURE_REPRESENTATION_ITEM' ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'VALUE_RANGE']* TYPEOF ( i ) ) =1 ) )
+        >0;
+	WR4 : ( SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'REPRESENTATION_RELATIONSHIP.'+
+        'REP_1' ) ) <=1 ) AND ( SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'REPRESENTATION_RELATIONSHIP.'+
+        'REP_2' ) ) =0 ) AND ( SIZEOF ( QUERY ( rr <* USEDIN ( SELF
+        , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'REPRESENTATION_RELATIONSHIP.'+
+        'REP_1' ) | rr. rep_2.name = 'measuring direction' ) ) =
+        SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'REPRESENTATION_RELATIONSHIP.'+
+        'REP_1' ) ) );
+	WR5 : ( SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) ) =1 ) AND ( SIZEOF ( QUERY ( pdr
+        <* USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) | SIZEOF ( QUERY ( gpa <* USEDIN (
+        pdr. definition ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'GENERAL_PROPERTY_ASSOCIATION.'+
+        'DERIVED_DEFINITION' ) | ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'GENERAL_PROPERTY' IN TYPEOF ( gpa. base_definition ) ) AND
+        ( gpa. base_definition.name ='surface_condition' ) ) ) =1 )
+        ) =1 );
+END_ENTITY;
+
+
+ENTITY surfaced_open_shell
+	SUBTYPE OF (open_shell);
+WHERE
+	WR1 : SIZEOF(QUERY(q <* SELF\connected_face_set.cfs_faces |
+         NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE' IN TYPEOF(q)))) = 0;
+END_ENTITY;
+
+
+ENTITY swept_area_solid
+	SUPERTYPE OF (ONEOF (revolved_area_solid, extruded_area_solid, surface_curve_swept_area_solid))
+	SUBTYPE OF (solid_model);
+	swept_area : curve_bounded_surface;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE' IN TYPEOF(swept_area.basis_surface);
+END_ENTITY;
+
+
+ENTITY swept_disk_solid
+	SUBTYPE OF (solid_model);
+	directrix : curve;
+	radius : positive_length_measure;
+	inner_radius : OPTIONAL positive_length_measure;
+	start_param : REAL;
+	end_param : REAL;
+WHERE
+	WR1 : directrix.dim = 3;
+	WR2 : (NOT EXISTS(inner_radius)) OR (radius > inner_radius);
+END_ENTITY;
+
+
+ENTITY swept_face_solid
+	SUPERTYPE OF (ONEOF (extruded_face_solid, revolved_face_solid))
+	SUBTYPE OF (solid_model);
+	swept_face : face_surface;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE' IN TYPEOF(swept_face.face_geometry);
+END_ENTITY;
+
+
+ENTITY swept_surface
+	SUPERTYPE OF (ONEOF (surface_of_linear_extrusion, surface_of_revolution))
+	SUBTYPE OF (surface);
+	swept_curve : curve;
+END_ENTITY;
+
+
+ENTITY symbol
+	SUBTYPE OF (representation_item);
+END_ENTITY;
+
+
+ENTITY symbol_colour;
+	colour_of_symbol : colour;
+END_ENTITY;
+
+
+ENTITY symbol_representation
+	SUBTYPE OF (representation);
+END_ENTITY;
+
+
+ENTITY symbol_representation_map
+	SUBTYPE OF (representation_map);
+	SELF\representation_map.mapped_representation : symbol_representation;
+	SELF\representation_map.mapping_origin : axis2_placement;
+END_ENTITY;
+
+
+ENTITY symbol_style
+	SUBTYPE OF (founded_item);
+	name : label;
+	style_of_symbol : symbol_style_select;
+END_ENTITY;
+
+
+ENTITY symbol_target
+	SUBTYPE OF (geometric_representation_item);
+	placement : axis2_placement;
+	x_scale : positive_ratio_measure;
+	y_scale : positive_ratio_measure;
+END_ENTITY;
+
+
+ENTITY symmetric_shape_aspect
+	SUBTYPE OF (shape_aspect);
+INVERSE
+	basis_relationships: SET [1:?] OF shape_aspect_relationship FOR relating_shape_aspect;
+WHERE
+	WR1 : SIZEOF (QUERY (x<*SELF\symmetric_shape_aspect.basis_relationships |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CENTRE_OF_SYMMETRY' IN TYPEOF 
+       (x\shape_aspect_relationship.related_shape_aspect)))>=1;
+END_ENTITY;
+
+
+ENTITY symmetry_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 3;
+END_ENTITY;
+
+
+ENTITY table_representation_item
+	SUBTYPE OF (compound_representation_item);
+WHERE
+	WR1 : SIZEOF(QUERY(itet <* SELF\compound_representation_item.item_element |
+        NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ROW_REPRESENTATION_ITEM' IN TYPEOF(itet))
+            )) = 0;
+END_ENTITY;
+
+
+ENTITY tactile_appearance_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : SIZEOF ( QUERY ( i <* SELF.items | SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MEASURE_REPRESENTATION_ITEM' ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'VALUE_RANGE']* TYPEOF ( i ) ) <>1 )) =0;
+	WR2 : SIZEOF ( QUERY ( i <* SELF.items | name ='depth' ) ) <=1;
+	WR3 : ( SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) ) =1 ) AND ( SIZEOF ( QUERY ( pdr
+        <* USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) | SIZEOF ( QUERY ( gpa <* USEDIN (
+        pdr. definition ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'GENERAL_PROPERTY_ASSOCIATION.'+
+        'DERIVED_DEFINITION' ) | ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'GENERAL_PROPERTY' IN TYPEOF ( gpa. base_definition ) ) AND
+        ( gpa. base_definition.name ='surface_condition' ) ) ) =1 )) =1 );
+END_ENTITY;
+
+
+ENTITY tagged_text_format
+	SUBTYPE OF (representation_context);
+END_ENTITY;
+
+
+ENTITY tagged_text_item
+	SUBTYPE OF (descriptive_representation_item);
+END_ENTITY;
+
+
+ENTITY tangent
+	SUBTYPE OF (derived_shape_aspect);
+WHERE
+	WR1 : SIZEOF (SELF\derived_shape_aspect.deriving_relationships)= 1;
+END_ENTITY;
+
+
+ENTITY terminator_symbol
+	SUBTYPE OF (annotation_symbol_occurrence);
+	annotated_curve : annotation_curve_occurrence;
+END_ENTITY;
+
+
+ENTITY text_font;
+	id : identifier;
+	name : label;
+	description : text;
+INVERSE
+	glyphs: SET [1:?] OF character_glyph_font_usage FOR font;
+END_ENTITY;
+
+
+ENTITY text_font_family;
+	id : identifier;
+	name : label;
+	description : text;
+INVERSE
+	fonts: SET [1:?] OF text_font_in_family FOR family;
+END_ENTITY;
+
+
+ENTITY text_font_in_family;
+	font : text_font;
+	family : text_font_family;
+END_ENTITY;
+
+
+ENTITY text_literal
+	SUBTYPE OF (geometric_representation_item);
+	literal : presentable_text;
+	placement : axis2_placement;
+	alignment : text_alignment;
+	path : text_path;
+	font : font_select;
+END_ENTITY;
+
+
+ENTITY text_literal_with_associated_curves
+	SUBTYPE OF (text_literal);
+	associated_curves : SET [1:?] OF curve;
+END_ENTITY;
+
+
+ENTITY text_literal_with_blanking_box
+	SUBTYPE OF (text_literal);
+	blanking : planar_box;
+END_ENTITY;
+
+
+ENTITY text_literal_with_delineation
+	SUBTYPE OF (text_literal);
+	delineation : text_delineation;
+END_ENTITY;
+
+
+ENTITY text_literal_with_extent
+	SUBTYPE OF (text_literal);
+	extent : planar_extent;
+END_ENTITY;
+
+
+ENTITY text_string_representation
+	SUBTYPE OF (representation);
+	SELF\representation.items : SET [1:?] OF text_string_representation_item;
+WHERE
+	WR1 : SIZEOF (
+         QUERY (item <* SELF\representation.items |
+           NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_CHARACTER',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEFINED_CHARACTER_GLYPH',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'] *
+                 TYPEOF (item)) = 0)
+         )) >= 1;
+	WR2 : SIZEOF (
+         QUERY (a2p <* 
+           QUERY (item <* SELF\representation.items | 
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT' IN TYPEOF (item)) |
+           NOT ((SIZEOF (
+             QUERY (at <* 
+               QUERY (item <* SELF\representation.items | 
+                  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+                  'ANNOTATION_TEXT' IN TYPEOF (item)) | 
+               (at\mapped_item.mapping_target :=: a2p))) >= 1) OR
+           (SIZEOF (
+             QUERY (atc <* 
+               QUERY (item <* SELF\representation.items |
+                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+                 'ANNOTATION_TEXT_CHARACTER' IN TYPEOF (item)) | 
+               (atc\mapped_item.mapping_target :=: a2p))) >= 1)
+          ))) = 0;
+END_ENTITY;
+
+
+ENTITY text_style
+	SUBTYPE OF (founded_item);
+	name : label;
+	character_appearance : character_style_select;
+END_ENTITY;
+
+
+ENTITY text_style_for_defined_font;
+	text_colour : colour;
+END_ENTITY;
+
+
+ENTITY text_style_with_box_characteristics
+	SUBTYPE OF (text_style);
+	characteristics : SET [1:4] OF box_characteristic_select;
+WHERE
+	WR1 : SIZEOF( QUERY( c1 <* SELF.characteristics |
+           SIZEOF( QUERY( c2 <* SELF.characteristics - c1 |
+           TYPEOF (c1) = TYPEOF (c2)
+           )) > 0
+           )) = 0;
+END_ENTITY;
+
+
+ENTITY text_style_with_mirror
+	SUBTYPE OF (text_style);
+	mirror_placement : axis2_placement;
+END_ENTITY;
+
+
+ENTITY text_style_with_spacing
+	SUBTYPE OF (text_style);
+	character_spacing : character_spacing_select;
+END_ENTITY;
+
+
+ENTITY thermal_resistance_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.THERMAL_RESISTANCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY thermal_resistance_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = 
+        dimensional_exponents ( -1.0, -1.0, -3.0, 0.0, 1.0, 0.0, 0.0 );
+END_ENTITY;
+
+
+ENTITY thermodynamic_temperature_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.THERMODYNAMIC_TEMPERATURE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY thermodynamic_temperature_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 1.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY thickened_face_solid
+	SUBTYPE OF (solid_model);
+	base_element : generalized_surface_select;
+	offset1 : length_measure;
+	offset2 : length_measure;
+WHERE
+	WR1 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE' IN TYPEOF(base_element)) AND
+    (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_SURFACE' IN TYPEOF(base_element))));
+	WR2 : offset1 <> offset2;
+END_ENTITY;
+
+
+ENTITY thickness_laminate_definition
+	SUBTYPE OF (product_definition);
+WHERE
+	WR1 : SIZEOF (QUERY (pdr <* USEDIN (SELF, 
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'PRODUCT_DEFINITION_RELATIONSHIP.' +
+                             'RELATING_PRODUCT_DEFINITION') |
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'NEXT_ASSEMBLY_USAGE_OCCURRENCE' IN
+                             TYPEOF (pdr))) = 1;
+END_ENTITY;
+
+
+ENTITY thickness_laminate_table
+	SUBTYPE OF (zone_structural_makeup);
+END_ENTITY;
+
+
+ENTITY time_interval;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY time_interval_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_time_interval : time_interval;
+	role : time_interval_role;
+END_ENTITY;
+
+
+ENTITY time_interval_based_effectivity
+	SUBTYPE OF (effectivity);
+	effectivity_period : time_interval;
+END_ENTITY;
+
+
+ENTITY time_interval_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_time_interval : time_interval;
+	related_time_interval : time_interval;
+END_ENTITY;
+
+
+ENTITY time_interval_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY time_interval_with_bounds
+	SUBTYPE OF (time_interval);
+	primary_bound : OPTIONAL date_time_or_event_occurrence;
+	secondary_bound : OPTIONAL date_time_or_event_occurrence;
+	duration : OPTIONAL time_measure_with_unit;
+WHERE
+	WR1 : NOT (EXISTS(secondary_bound) AND EXISTS(duration));
+	WR2 : EXISTS(primary_bound) OR EXISTS(secondary_bound);
+END_ENTITY;
+
+
+ENTITY time_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TIME_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY time_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 1.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY tolerance_value;
+	lower_bound : measure_with_unit;
+	upper_bound : measure_with_unit;
+DERIVE
+	lbvc : REAL := lower_bound\measure_with_unit.value_component;
+	ubvc : REAL := upper_bound\measure_with_unit.value_component;
+WHERE
+	WR1 : ubvc > lbvc;
+	WR2 : upper_bound\measure_with_unit.unit_component =
+        lower_bound\measure_with_unit.unit_component;
+END_ENTITY;
+
+
+ENTITY tolerance_zone
+	SUBTYPE OF (shape_aspect);
+	defining_tolerance : SET [1:?] OF geometric_tolerance;
+	form : tolerance_zone_form;
+END_ENTITY;
+
+
+ENTITY tolerance_zone_definition
+	SUPERTYPE OF (ONEOF (projected_zone_definition, runout_zone_definition));
+	zone : tolerance_zone;
+	boundaries : SET [1:?] OF shape_aspect;
+END_ENTITY;
+
+
+ENTITY tolerance_zone_form;
+	name : label;
+END_ENTITY;
+
+
+ENTITY topological_representation_item
+	SUPERTYPE OF (ONEOF (vertex, edge, face_bound, face, vertex_shell, wire_shell, connected_edge_set, connected_face_set, (loop ANDOR path)))
+	SUBTYPE OF (representation_item);
+END_ENTITY;
+
+
+ENTITY toroidal_surface
+	SUBTYPE OF (elementary_surface);
+	major_radius : positive_length_measure;
+	minor_radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY torus
+	SUBTYPE OF (geometric_representation_item);
+	position : axis1_placement;
+	major_radius : positive_length_measure;
+	minor_radius : positive_length_measure;
+WHERE
+	WR1 : major_radius > minor_radius;
+END_ENTITY;
+
+
+ENTITY total_runout_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 2;
+END_ENTITY;
+
+
+ENTITY track_blended_solid
+	ABSTRACT SUPERTYPE OF (track_blended_solid_with_end_conditions)
+	SUBTYPE OF (edge_blended_solid);
+WHERE
+	WR1 : check_continuous_edges(SELF\edge_blended_solid.blended_edges);
+END_ENTITY;
+
+
+ENTITY track_blended_solid_with_end_conditions
+	SUBTYPE OF (track_blended_solid);
+	end_conditions : LIST [2:2] OF blend_end_condition_select;
+WHERE
+	WR1 : SIZEOF(TYPEOF(SELF) *
+    ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_CONSTANT_RADIUS_EDGE_BLEND',
+     'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_VARIABLE_RADIUS_EDGE_BLEND',
+     'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_CHAMFERED_EDGES']) = 1;
+	WR2 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX' IN TYPEOF(end_conditions[1]))
+       AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX' IN TYPEOF(end_conditions[2])));
+	WR3 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX' IN TYPEOF(end_conditions[1]))
+       AND (NOT ((end_conditions[1] 
+            :=: SELF\edge_blended_solid.blended_edges[1].edge_start)
+            XOR (end_conditions[1] 
+            :=: SELF\edge_blended_solid.blended_edges[1].edge_end))));
+	WR4 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX' IN TYPEOF(end_conditions[2]))
+       AND (NOT ((end_conditions[2] 
+            :=: SELF\edge_blended_solid.blended_edges[HIINDEX(
+                SELF\edge_blended_solid.blended_edges)].edge_start)
+            XOR (end_conditions[2] 
+            :=: SELF\edge_blended_solid.blended_edges[HIINDEX(
+                SELF\edge_blended_solid.blended_edges)].edge_end))));
+END_ENTITY;
+
+
+ENTITY transformation_with_derived_angle
+	SUPERTYPE OF (ONEOF (draped_defined_transformation, laid_defined_transformation))
+	SUBTYPE OF (item_defined_transformation);
+	SELF\item_defined_transformation.transform_item_1 : angle_direction_reference_with_a2p3d_select;
+	SELF\item_defined_transformation.transform_item_2 : axis2_placement_3d;
+DERIVE
+	orientation_angle : plane_angle_measure := derive_angle (
+        SELF\item_defined_transformation.transform_item_1,
+        SELF\item_defined_transformation.transform_item_2);
+WHERE
+	WR1 : (SELF\item_defined_transformation.transform_item_1\
+            axis2_placement_3d.p[3].direction_ratios[1] =
+            SELF\item_defined_transformation.transform_item_2\
+            axis2_placement_3d.p[3].direction_ratios[1])
+          AND
+           (SELF\item_defined_transformation.transform_item_1\
+            axis2_placement_3d.p[3].direction_ratios[2] =
+            SELF\item_defined_transformation.transform_item_2\
+            axis2_placement_3d.p[3].direction_ratios[2])
+          AND
+           (SELF\item_defined_transformation.transform_item_1\
+            axis2_placement_3d.p[3].direction_ratios[3] =
+            SELF\item_defined_transformation.transform_item_2\
+            axis2_placement_3d.p[3].direction_ratios[3]);
+END_ENTITY;
+
+
+ENTITY trimmed_curve
+	SUBTYPE OF (bounded_curve);
+	basis_curve : curve;
+	trim_1 : SET [1:2] OF trimming_select;
+	trim_2 : SET [1:2] OF trimming_select;
+	sense_agreement : BOOLEAN;
+	master_representation : trimming_preference;
+WHERE
+	WR1 : (HIINDEX(trim_1) = 1) OR (TYPEOF(trim_1[1]) <> TYPEOF(trim_1[2]));
+	WR2 : (HIINDEX(trim_2) = 1) OR (TYPEOF(trim_2[1]) <> TYPEOF(trim_2[2]));
+END_ENTITY;
+
+
+ENTITY two_direction_repeat_factor
+	SUBTYPE OF (one_direction_repeat_factor);
+	second_repeat_factor : vector;
+END_ENTITY;
+
+
+ENTITY type_qualifier;
+	name : label;
+END_ENTITY;
+
+
+ENTITY unary_generic_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (generic_expression);
+	operand : generic_expression;
+END_ENTITY;
+
+
+ENTITY unary_numeric_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (numeric_expression, unary_generic_expression);
+	SELF\unary_generic_expression.operand : numeric_expression;
+END_ENTITY;
+
+
+ENTITY uncertainty_assigned_representation
+	SUBTYPE OF (representation);
+	uncertainty : SET [1:?] OF uncertainty_measure_with_unit;
+END_ENTITY;
+
+
+ENTITY uncertainty_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+	name : label;
+	description : OPTIONAL text;
+WHERE
+	WR1 : valid_measure_value (SELF\measure_with_unit.value_component);
+END_ENTITY;
+
+
+ENTITY uncertainty_qualifier
+	SUPERTYPE OF (ONEOF (standard_uncertainty, qualitative_uncertainty));
+	measure_name : label;
+	description : text;
+END_ENTITY;
+
+
+ENTITY uniform_curve
+	SUBTYPE OF (b_spline_curve);
+END_ENTITY;
+
+
+ENTITY uniform_resource_identifier
+	SUBTYPE OF (descriptive_representation_item);
+END_ENTITY;
+
+
+ENTITY uniform_surface
+	SUBTYPE OF (b_spline_surface);
+END_ENTITY;
+
+
+ENTITY usage_association
+	SUBTYPE OF (action_method_relationship);
+	SELF\action_method_relationship.related_method : information_usage_right;
+	SELF\action_method_relationship.relating_method : information_usage_right;
+DERIVE
+	related : information_usage_right := SELF\action_method_relationship.related_method;
+	relating : information_usage_right := SELF\action_method_relationship.relating_method;
+END_ENTITY;
+
+
+ENTITY user_defined_curve_font
+	SUBTYPE OF (curve_style_font, mapped_item);
+END_ENTITY;
+
+
+ENTITY user_defined_marker
+	SUBTYPE OF (mapped_item, pre_defined_marker);
+END_ENTITY;
+
+
+ENTITY user_defined_terminator_symbol
+	SUBTYPE OF (mapped_item, pre_defined_symbol);
+END_ENTITY;
+
+
+ENTITY user_selected_elements
+	SUBTYPE OF (representation_item);
+	picked_items : SET [1:?] OF representation_item;
+END_ENTITY;
+
+
+ENTITY user_selected_shape_elements
+	SUBTYPE OF (user_selected_elements);
+WHERE
+	WR1 : SIZEOF(QUERY(q <* 
+    SELF\user_selected_elements.picked_items | NOT
+    ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION_ITEM'
+    IN TYPEOF(q)))) = 0;
+END_ENTITY;
+
+
+ENTITY value_range
+	SUBTYPE OF (compound_representation_item);
+WHERE
+	WR1 : ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'SET_REPRESENTATION_ITEM' IN TYPEOF ( item_element ) ) AND value_range_wr1 ( item_element );
+	WR2 : value_range_wr2 ( item_element );
+	WR3 : value_range_wr3 ( item_element );
+END_ENTITY;
+
+
+ENTITY value_representation_item
+	SUBTYPE OF (representation_item);
+	value_component : measure_value;
+WHERE
+	WR1 : SIZEOF (QUERY (rep <* using_representations (SELF) |
+        NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GLOBAL_UNIT_ASSIGNED_CONTEXT'
+        IN TYPEOF (rep.context_of_items)
+        ))) = 0;
+END_ENTITY;
+
+
+ENTITY variable_semantics
+	ABSTRACT SUPERTYPE;
+END_ENTITY;
+
+
+ENTITY variational_representation_item
+	ABSTRACT SUPERTYPE OF (auxiliary_geometric_representation_item)
+	SUBTYPE OF (representation_item);
+WHERE
+	WR1 : SIZEOF(QUERY(q <* using_representations(SELF) |
+    NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VARIATIONAL_REPRESENTATION'  
+    IN TYPEOF(q)))) = 0;
+	WR2 : SIZEOF(QUERY(q <* using_representations(SELF) |
+    NOT (SELF IN q.items))) = 0;
+END_ENTITY;
+
+
+ENTITY vector
+	SUBTYPE OF (geometric_representation_item);
+	orientation : direction;
+	magnitude : length_measure;
+WHERE
+	WR1 : magnitude >= 0.0;
+END_ENTITY;
+
+
+ENTITY vector_style
+	SUBTYPE OF (curve_style, pre_defined_terminator_symbol);
+END_ENTITY;
+
+
+ENTITY velocity_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VELOCITY_UNIT' IN TYPEOF (SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY velocity_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = 
+       dimensional_exponents ( 1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0 );
+END_ENTITY;
+
+
+ENTITY versioned_action_request;
+	id : identifier;
+	version : label;
+	purpose : text;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY vertex
+	SUBTYPE OF (topological_representation_item);
+END_ENTITY;
+
+
+ENTITY vertex_loop
+	SUBTYPE OF (loop);
+	loop_vertex : vertex;
+END_ENTITY;
+
+
+ENTITY vertex_point
+	SUBTYPE OF (vertex, geometric_representation_item);
+	vertex_geometry : point;
+END_ENTITY;
+
+
+ENTITY vertex_shell
+	SUBTYPE OF (topological_representation_item);
+	vertex_shell_extent : vertex_loop;
+END_ENTITY;
+
+
+ENTITY view_volume
+	SUBTYPE OF (founded_item);
+	projection_type : central_or_parallel;
+	projection_point : cartesian_point;
+	view_plane_distance : length_measure;
+	front_plane_distance : length_measure;
+	front_plane_clipping : BOOLEAN;
+	back_plane_distance : length_measure;
+	back_plane_clipping : BOOLEAN;
+	view_volume_sides_clipping : BOOLEAN;
+	view_window : planar_box;
+END_ENTITY;
+
+
+ENTITY visual_appearance_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : ( {3<= SIZEOF ( SELF.items ) <=9} ) AND ( SIZEOF ( QUERY (
+        i <* items | ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF ( i ) ) AND (
+        i.name IN [ 'colour id' , 'colour name' , 'lustre' , 'pattern' , 'transparency', 'orientation'] ) ) 
+        ) + SIZEOF ( QUERY ( i <* items | ( SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MEASURE_REPRESENTATION_ITEM' ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'VALUE_RANGE']* TYPEOF ( i ) ) =1 )							
+        AND ( i.name IN ['refraction index' , 'opacity'] ) ) 
+        ) + SIZEOF ( QUERY ( i <* items | ( 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'DOCUMENT_FILE' IN TYPEOF ( i ) ) 
+        AND ( i.name IN [ 'texture map' ] ) )	)
+        = SIZEOF ( SELF.items ) );
+	WR2 : SIZEOF ( QUERY ( i <* SELF.items | i.name = 'colour id' )) =1;
+	WR3 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='lustre' ) )=1;
+	WR4 : SIZEOF ( QUERY ( i <* SELF.items | i.name = 'colour name') ) <=1;
+	WR5 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='pattern' ) )<=1;
+	WR6 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='transparency') ) <=1;
+	WR7 : SIZEOF ( QUERY ( i <* SELF.items | i.name = 'texture map') ) <=1;
+	WR8 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='refraction index' ) )<=1;
+	WR9 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='opacity') ) <=1;
+	WR10 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='orientation') ) <=1;
+	WR11 : ( SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) ) =1 ) AND ( SIZEOF ( QUERY ( pdr
+        <* USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) | SIZEOF ( QUERY ( gpa <* USEDIN (
+        pdr. definition ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'GENERAL_PROPERTY_ASSOCIATION.'+
+        'DERIVED_DEFINITION' ) | ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'GENERAL_PROPERTY' IN TYPEOF ( gpa. base_definition ) ) AND
+        ( gpa. base_definition.name ='surface_condition' ) ) ) =1 )) =1 );
+END_ENTITY;
+
+
+ENTITY volume_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VOLUME_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY volume_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = 
+          dimensional_exponents ( 3.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 );
+END_ENTITY;
+
+
+ENTITY week_of_year_and_day_date
+	SUBTYPE OF (date);
+	week_component : week_in_year_number;
+	day_component : OPTIONAL day_in_week_number;
+END_ENTITY;
+
+
+ENTITY wire_shell
+	SUBTYPE OF (topological_representation_item);
+	wire_shell_extent : SET [1:?] OF loop;
+WHERE
+	WR1 : NOT mixed_loop_type_set(wire_shell_extent);
+END_ENTITY;
+
+
+ENTITY year_month
+	SUBTYPE OF (date);
+	month_component : month_in_year_number;
+END_ENTITY;
+
+
+ENTITY zone_structural_makeup
+	SUPERTYPE OF (ONEOF ((smeared_material_definition AND thickness_laminate_table), (smeared_material_definition AND percentage_laminate_table), thickness_laminate_table, percentage_laminate_table, smeared_material_definition))
+	SUBTYPE OF (laminate_table);
+END_ENTITY;
+
+
+RULE alternative_solution_requires_solution_definition FOR (product_definition_formation);
+    LOCAL
+      solution_versions: SET OF product_definition_formation := [];
+    END_LOCAL;
+    solution_versions :=  QUERY( pdf <* product_definition_formation |
+	  SIZEOF( QUERY( prpc <* USEDIN(pdf.of_product, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') | 
+      prpc.name = 'alternative solution')) = 1);
+WHERE
+	WR1 : SIZEOF( QUERY( pdf <* solution_versions |
+        SIZEOF( QUERY( pd <* USEDIN(pdf, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.PRODUCT_DEFINITION.FORMATION') | 
+        pd.frame_of_reference.name = 'alternative definition')) <> 1))= 0;
+END_RULE;
+
+RULE application_protocol_definition_required FOR (application_context);
+
+WHERE
+	WR1 : SIZEOF( QUERY( ac <* application_context | 
+              (SIZEOF (QUERY (apd <* USEDIN(ac,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.APPLICATION_PROTOCOL_DEFINITION.APPLICATION') | 
+                apd.application_interpreted_model_schema_name = 'ap203_configuration_controlled_3d_design_of_mechanical_parts_and_assemblies' 
+                )) > 0) 
+              )) > 0;
+END_RULE;
+
+RULE breakdown_element_requires_product_definition FOR (product_definition_formation);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pdf <* product_definition_formation | 
+        ( SIZEOF ( QUERY ( prpc <* USEDIN ( pdf.of_product ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS' ) | 
+	    prpc.name =  'functionality' ) ) =  1 ) AND 
+	    ( SIZEOF ( QUERY ( pd <* USEDIN ( pdf ,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION.FORMATION') | 
+	    pd.frame_of_reference.name =  'functional definition' ) ) <1 ) ) ) =  0;
+	WR2 : SIZEOF ( QUERY ( pdf <* product_definition_formation | 
+        ( SIZEOF ( QUERY ( prpc <* USEDIN ( pdf.of_product , 
+	    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS' ) | 
+        prpc.name =  'conceptual design' ) ) =  1 ) AND 
+        ( SIZEOF (QUERY ( pd <* USEDIN ( pdf , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION.FORMATION' ) | 
+        pd.frame_of_reference.name =  'conceptual definition' ) ) <1) ) ) =  0;
+END_RULE;
+
+RULE compatible_dimension FOR (cartesian_point, direction, representation_context, geometric_representation_context);
+
+WHERE
+	WR1 : SIZEOF(QUERY(x <* cartesian_point| SIZEOF(QUERY
+       (y <* geometric_representation_context | item_in_context(x,y) AND
+       (HIINDEX(x.coordinates) <> y.coordinate_space_dimension))) > 0 )) =0;
+	WR2 : SIZEOF(QUERY(x <* direction | SIZEOF( QUERY
+       (y <* geometric_representation_context | item_in_context(x,y) AND
+       (HIINDEX(x.direction_ratios) <> y.coordinate_space_dimension)))
+       > 0 )) = 0;
+END_RULE;
+
+RULE component_class_for_assembly_select FOR (composite_assembly_sequence_definition, next_assembly_usage_occurrence, product_related_product_category);
+    LOCAL
+      i,j,k :  INTEGER :=0;
+      dkuhr :  LOGICAL :=TRUE;
+      nnauo :  INTEGER :=0;
+      nprpc :  INTEGER :=0;
+      rp    :  product;
+    END_LOCAL;
+    REPEAT i:= LOINDEX (composite_assembly_sequence_definition) TO
+               HIINDEX (composite_assembly_sequence_definition);
+      nnauo := 0;  
+      REPEAT j:= LOINDEX (next_assembly_usage_occurrence) TO
+                 HIINDEX (next_assembly_usage_occurrence);
+        IF (composite_assembly_sequence_definition[i] = 
+          next_assembly_usage_occurrence[j].relating_product_definition) THEN
+          rp := next_assembly_usage_occurrence[j].related_product_definition.
+                formation.of_product;
+          nprpc := 0;
+          REPEAT k:= LOINDEX (product_related_product_category) TO
+                     HIINDEX (product_related_product_category);
+            IF ((rp IN product_related_product_category[k].products) AND
+                (product_related_product_category[k].name IN ['ply',
+                 'ply laminate', 'filament laminate', 'processed core',
+                 'composite assembly'])) THEN
+                nprpc := nprpc + 1;
+            END_IF;
+          END_REPEAT;
+          IF (nprpc = 1) THEN
+            nnauo := nnauo + 1;
+          ELSE
+            dkuhr := FALSE;
+            ESCAPE;
+          END_IF;
+        END_IF;
+      END_REPEAT;
+      IF (dkuhr = FALSE) THEN
+        ESCAPE; 
+      END_IF;
+      IF(nnauo = 0) THEN
+        dkuhr := FALSE;
+        ESCAPE;
+      END_IF;
+    END_REPEAT;
+WHERE
+	WR1 : dkuhr;
+END_RULE;
+
+RULE consistent_uncertainty FOR (global_uncertainty_assigned_context, qualified_representation_item, uncertainty_assigned_representation);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( guac <* global_uncertainty_assigned_context | 
+    SIZEOF ( QUERY ( u1 <* guac.uncertainty | 
+	SIZEOF ( QUERY ( u2 <* guac.uncertainty | u2.name =  u1.name ) ) >1 ) ) >0 ) ) =  0;
+	WR2 : SIZEOF ( QUERY ( uar <* uncertainty_assigned_representation | 
+	SIZEOF ( QUERY ( u1<* uar.uncertainty | 
+	SIZEOF ( QUERY ( u2 <* uar.uncertainty | u2.name =  u1.name ) ) >1 ) ) >0 ) ) =  0;
+	WR3 : SIZEOF ( QUERY ( qri <* qualified_representation_item |
+     SIZEOF ( QUERY ( u1 <* qri.qualifiers |
+     ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.UNCERTAINTY_QUALIFIER' IN TYPEOF ( u1 ) ) AND 
+	( SIZEOF ( QUERY ( u2 <* qri.qualifiers |
+     ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.UNCERTAINTY_QUALIFIER' IN TYPEOF ( u2 ) ) AND 
+	( u2\uncertainty_qualifier.measure_name =  u1\uncertainty_qualifier.measure_name ) )
+     ) >1 ) ) ) >0 ) ) =  0;
+END_RULE;
+
+RULE constraint_definition_requires_constraint_category FOR (product_definition);
+    LOCAL
+      constraint_definitions: SET OF product_definition := [];
+    END_LOCAL;
+      constraint_definitions :=  QUERY( pd <* product_definition |
+      (pd.frame_of_reference.name = 'design constraint definition'));
+WHERE
+	WR1 : SIZEOF ( QUERY ( pd <* constraint_definitions | 
+	    ( SIZEOF ( QUERY ( prpc <* USEDIN ( pd.formation.of_product ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS' ) | 
+	    prpc. name ='requirement' ) ) =0 ) ) ) =0;
+END_RULE;
+
+RULE design_constraint_requires_product_definition FOR (product_definition_formation);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pdf <* product_definition_formation | (
+        SIZEOF ( QUERY ( prpc <* USEDIN ( pdf.of_product ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS' ) | 
+	    prpc.name =  'requirement' ) ) >0 ) AND 
+        ( SIZEOF ( QUERY ( pd <* USEDIN ( pdf , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION.FORMATION') | 
+	    pd.frame_of_reference.name = 'design constraint definition' ) ) <1 ) ) ) =  0;
+END_RULE;
+
+RULE draughting_model_items_constraint FOR (draughting_model);
+
+WHERE
+	WR1 : SIZEOF(QUERY(dm <* draughting_model |
+        NOT(SIZEOF(QUERY(it1 <* dm\representation.items |
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_OCCURRENCE' IN TYPEOF(it1))
+        AND
+        NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DRAUGHTING_ANNOTATION_OCCURRENCE' IN TYPEOF(it1)))
+          )) = 0)
+        )) = 0;
+	WR2 : SIZEOF(QUERY(dm <* draughting_model |
+        NOT(SIZEOF(QUERY(it1 <* dm\representation.items |
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT' IN TYPEOF(it1))
+        AND
+        NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_ELEMENTS' IN TYPEOF(it1)))
+          )) = 0)
+        )) = 0;
+END_RULE;
+
+RULE external_version_assignments_are_valid FOR (applied_external_identification_assignment);
+
+WHERE
+	WR1 : SIZEOF(QUERY(aia <* applied_external_identification_assignment | 
+        NOT external_version_assignment_is_valid(aia)))=0;
+END_RULE;
+
+RULE material_for_coating_layer FOR (shape_aspect);
+    LOCAL
+      coating_layers: SET OF shape_aspect := [];
+    END_LOCAL;
+    coating_layers:= QUERY( r <* shape_aspect | 
+	  (r.name = 'coating layer') );
+WHERE
+	WR1 : SIZEOF( QUERY( r <* coating_layers |
+	    SIZEOF(USEDIN(r , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MATERIAL_DESIGNATION.DEFINITIONS'))<>1
+        )) = 0;
+END_RULE;
+
+RULE plib_property_reference_requires_name_scope FOR (externally_defined_general_property);
+    LOCAL
+      known_sourced_properties : SET OF externally_defined_general_property;
+    END_LOCAL;
+      known_sourced_properties := QUERY( edc <* externally_defined_general_property | 
+	    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'KNOWN_SOURCE' IN TYPEOF(edc.source) );
+WHERE
+	WR1 : SIZEOF ( QUERY ( edgp <* known_sourced_properties | 
+        ( SIZEOF ( QUERY ( edir <* USEDIN ( edgp, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'EXTERNALLY_DEFINED_ITEM_RELATIONSHIP.RELATING_ITEM' )| 
+        ( edir.name =  'name scope' ) AND 
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'EXTERNALLY_DEFINED_CLASS' IN  TYPEOF ( edir.related_item ) ) AND 
+        ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'KNOWN_SOURCE' IN TYPEOF ( edir.related_item.source ) ) ) ) <>1 ) ) ) =  0;
+END_RULE;
+
+RULE plib_property_reference_requires_version FOR (externally_defined_general_property);
+	LOCAL
+	  plib_properties : SET OF externally_defined_general_property := [];
+	END_LOCAL;
+	  plib_properties := QUERY ( edgp <* externally_defined_general_property | 
+		( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'KNOWN_SOURCE' IN TYPEOF ( edgp.source ) ) AND
+		( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'KNOWN_SOURCE' + '.NAME' = 'ISO 13584 library' ) );
+WHERE
+	WR1 : SIZEOF( QUERY( edgp <* plib_properties | 
+		(SIZEOF( QUERY( edir <* USEDIN(edgp, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT.ITEMS') | 
+		(edir.role.name = 'version') )) <> 1) )) = 0;
+END_RULE;
+
+RULE ply_reference FOR (ply_laminate_sequence_definition, next_assembly_usage_occurrence, product_related_product_category);
+    LOCAL
+      i,j,k :  INTEGER;
+      dkuhr :  LOGICAL := TRUE;
+      nnauo :  INTEGER;
+      nprpc :  INTEGER := 0;
+      rp    :  product;
+    END_LOCAL;
+    REPEAT i:= LOINDEX (ply_laminate_sequence_definition) TO
+               HIINDEX (ply_laminate_sequence_definition);
+      nnauo := 0;  
+      REPEAT j:= LOINDEX (next_assembly_usage_occurrence) TO 
+                 HIINDEX (next_assembly_usage_occurrence);
+        IF (ply_laminate_sequence_definition[i] = 
+          next_assembly_usage_occurrence[j].relating_product_definition) THEN
+          rp := next_assembly_usage_occurrence[j].related_product_definition.
+                formation.of_product;
+          nprpc := 0;
+          REPEAT k:= LOINDEX (product_related_product_category) TO
+                     HIINDEX (product_related_product_category);
+            IF ((product_related_product_category[k].name = 'ply') AND
+                (rp IN product_related_product_category[k].products)) THEN
+                nprpc := nprpc + 1;
+            END_IF;
+          END_REPEAT;
+          IF (nprpc = 1) THEN
+            nnauo := nnauo + 1;
+          ELSE
+            dkuhr := FALSE;
+            ESCAPE;
+          END_IF;
+        END_IF;
+      END_REPEAT;
+      IF (dkuhr = FALSE) THEN
+        ESCAPE; 
+      END_IF;
+      IF(nnauo = 0) THEN
+        dkuhr := FALSE;
+        ESCAPE;
+      END_IF;
+    END_REPEAT;
+WHERE
+	WR1 : dkuhr;
+END_RULE;
+
+RULE ply_stock_material_select FOR (product_related_product_category, make_from_usage_option);
+  LOCAL
+    i,j,k,kp :  INTEGER;
+    dkuhr    :  LOGICAL;
+    nmfuo    :  INTEGER;
+    nprpc    :  INTEGER := 0;
+    rp       :  product;
+  END_LOCAL;
+
+  dkuhr := TRUE;
+  REPEAT kp:= LOINDEX (product_related_product_category) TO
+              HIINDEX (product_related_product_category);
+ 
+    IF (product_related_product_category[kp].name = 'ply') THEN
+    REPEAT i:= LOINDEX (product_related_product_category[kp].products) TO
+               HIINDEX (product_related_product_category[kp].products);
+
+      nmfuo := 0;  
+      REPEAT j:= LOINDEX (make_from_usage_option) TO 
+                 HIINDEX (make_from_usage_option);
+
+          rp := make_from_usage_option[j].related_product_definition.
+                formation.of_product;
+
+        IF (product_related_product_category[kp].products[i] = rp) THEN
+
+          REPEAT k:= LOINDEX (product_related_product_category) TO
+                     HIINDEX (product_related_product_category);
+
+            IF ((rp IN product_related_product_category[k].products) AND
+                (product_related_product_category[k].name IN 
+                 ['isotropic material', 'filament assembly', 
+                  'discontinuous fiber assembly'])) THEN
+                nprpc := nprpc + 1;
+            END_IF;
+
+          END_REPEAT;
+
+          IF (nprpc = 1) THEN
+            nmfuo := nmfuo + 1;
+          ELSE
+            dkuhr := FALSE;
+            ESCAPE;
+          END_IF;
+
+        END_IF;
+
+      END_REPEAT;
+
+      IF (dkuhr = FALSE) THEN
+        ESCAPE; 
+      END_IF;
+      IF(nmfuo <> 1) THEN
+        dkuhr := FALSE;
+        ESCAPE;
+      END_IF;
+
+    END_REPEAT;
+    END_IF;
+
+  END_REPEAT;
+WHERE
+	WR1 : dkuhr;
+END_RULE;
+
+RULE product_concept_feature_requires_category FOR (product_concept_feature);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pcf <* product_concept_feature |
+(SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'INCLUSION_PRODUCT_CONCEPT_FEATURE',
+'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONDITIONAL_CONCEPT_FEATURE'] * TYPEOF(pcf)) = 0) AND 
+(SIZEOF ( QUERY ( aga <* USEDIN ( pcf , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'APPLIED_GROUP_ASSIGNMENT.' + 'ITEMS' ) | 
+( aga.role.name = 'specification category member' ) AND 
+('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRODUCT_CONCEPT_FEATURE_CATEGORY' IN TYPEOF ( aga.assigned_group )))) <>1 ) ) ) = 0;
+END_RULE;
+
+RULE product_definition_replacement_requires_effectivity_assignment FOR (product_definition_relationship);
+
+WHERE
+	WR1 : SIZEOF( QUERY( pdr <* product_definition_relationship | 
+        (pdr.name = 'definition replacement') AND 
+        (SIZEOF( USEDIN(pdr,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.APPLIED_EFFECTIVITY_ASSIGNMENT.ITEMS') ) = 0) ))
+        = 0;
+END_RULE;
+
+RULE restrict_alternative_definition FOR (product_definition);
+    LOCAL
+      solution_definitions: SET OF product_definition := [];
+    END_LOCAL;
+      solution_definitions :=  QUERY( pd <* product_definition |
+	 (pd.frame_of_reference.name = 'alternative definition'));
+WHERE
+	WR1 : SIZEOF ( QUERY ( pd <* solution_definitions | 
+	    ( SIZEOF ( QUERY ( pdr <* USEDIN ( pd ,
+	    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.PRODUCT_DEFINITION_RELATIONSHIP.RELATED_PRODUCT_DEFINITION' ) | 
+	    pdr.name = 'solution alternative definition' ) ) <>1 ) ) ) = 0;
+	WR2 : SIZEOF ( QUERY ( pd <* solution_definitions | 
+	    NOT ( pd.name IN ['technical' , 'supplier' , 'technical supplier' , ''] ) ) ) = 0;
+	WR3 : SIZEOF ( QUERY ( pd <* solution_definitions | 
+	    ( pd.name IN ['supplier' , 'technical supplier'] ) AND (
+	    SIZEOF ( QUERY ( aoa <* USEDIN ( pd.formation ,
+	    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.APPLIED_ORGANIZATION_ASSIGNMENT.ITEMS' ) | 
+	    aoa.role.name = 'supplier' )) <>1 ) )) = 0;
+END_RULE;
+
+RULE restrict_assembly_category FOR (product_definition);
+    LOCAL
+      assembly_definitions: SET OF product_definition := [];
+    END_LOCAL;
+      assembly_definitions :=  QUERY( pd <* product_definition | 
+        SIZEOF( QUERY( pdca <* USEDIN( pd, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_CONTEXT_ASSOCIATION.DEFINITION') |
+        pdca.frame_of_reference.name= 'assembly definition')) > 0 );
+WHERE
+	WR1 : SIZEOF( QUERY( pd <* assembly_definitions | 
+          NOT ('assembly' IN categories_of_product(pd.formation.of_product)) ))= 0;
+END_RULE;
+
+RULE restrict_centre_of_mass_representation FOR (representation);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( r <* representation | 
+	( r.name ='centre of mass' ) AND 
+	( ( SIZEOF ( r.items ) <>1 ) OR 
+	(SIZEOF ( QUERY ( i <* r.items | 
+	( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'POINT' IN TYPEOF ( i ) ) AND 
+	( i.name = 'centre point' ) )) <>1 ) ) ) ) 
+	=0;
+END_RULE;
+
+RULE restrict_classification_assignments FOR (applied_classification_assignment);
+
+WHERE
+	WR1 : SIZEOF(QUERY(aia <* applied_classification_assignment | 
+		NOT class_assignment_is_valid(aia)))=0;
+END_RULE;
+
+RULE restrict_collection_category FOR (product_definition);
+    LOCAL
+      collection_definitions: SET OF product_definition := [];
+    END_LOCAL;
+      collection_definitions :=  QUERY( pd <* product_definition | 
+        SIZEOF( QUERY( pdca <* USEDIN( pd, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.PRODUCT_DEFINITION_CONTEXT_ASSOCIATION.DEFINITION') |
+        pdca.frame_of_reference.name= 'collection definition')) > 0 );
+WHERE
+	WR1 : SIZEOF( QUERY( pd <* collection_definitions | 
+	    NOT ('collection' IN categories_of_product(pd.formation.of_product)) ))= 0;
+END_RULE;
+
+RULE restrict_concept_feature_operator FOR (concept_feature_operator);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( cfo <* concept_feature_operator | NOT
+		( cfo.name IN ['and' , 'or' , 'oneof' , 'not' , 'implication'] ) ) ) = 0;
+	WR2 : SIZEOF ( QUERY ( cfo <* concept_feature_operator | (cfo.name = 'implication' ) AND
+	 ( SIZEOF ( QUERY (cfrwc <* USEDIN ( cfo , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONCEPT_FEATURE_RELATIONSHIP_WITH_CONDITION.' +
+	'CONDITIONAL_OPERATOR' ) | 
+		SIZEOF ( QUERY ( ccf <* USEDIN( cfrwc , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONDITIONAL_CONCEPT_FEATURE.CONDITION' ) | 
+		NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'INCLUSION_PRODUCT_CONCEPT_FEATURE' IN TYPEOF ( ccf )))) >0 )) >0 ))) = 0;
+	WR3 : SIZEOF( QUERY (cfo <* concept_feature_operator | (cfo.name = 'not')
+	AND (SIZEOF(QUERY(cfrwc <* USEDIN(cfo, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONCEPT_FEATURE_RELATIONSHIP_WITH_CONDITION.CONDITIONAL_OPERATOR') | 
+		cfrwc.related_product_concept_feature :<>: cfrwc.relating_product_concept_feature)) >0 ))) = 0;
+END_RULE;
+
+RULE restrict_configuration_design_for_class_breakdown_association FOR (configuration_design);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( cd <* configuration_design | 
+	    ( cd.name ='functionality' ) AND 
+        ( NOT ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF ( cd. design ) ) OR 
+        ( cd.design\product_definition.frame_of_reference.name<> 'functional definition' ) ) 
+        ) ) =0;
+	WR2 : SIZEOF ( QUERY ( cd <* configuration_design | 
+        ( cd.name='realization' ) AND 
+        ( NOT ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF ( cd.design ) ) OR 
+        ( cd.design\product_definition.frame_of_reference.name<> 'conceptual definition' ) ) 
+        ) ) =0;
+	WR3 : SIZEOF ( QUERY ( cd <* configuration_design | 
+        ( cd.name IN ['functionality' , 'realization'] ) AND 
+        ( NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_CLASS' IN TYPEOF ( cd.configuration.item_concept ) ) ) 
+        ) ) =0;
+END_RULE;
+
+RULE restrict_configuration_design_for_design_constraint FOR (configuration_design);
+
+WHERE
+	WR1 : SIZEOF ( QUERY (cd <* configuration_design | 
+	    (cd.name = 'design constraint usage') AND 
+        (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF ( cd.design ) ) OR 
+        (cd.design\product_definition.frame_of_reference.name <> 'design constraint definition')))) = 0;
+END_RULE;
+
+RULE restrict_group_relationship_for_classification_hierarchy FOR (group_relationship);
+
+WHERE
+	WR1 : SIZEOF( QUERY( gr <* group_relationship | 
+  (gr\group_relationship.name = 'class hierarchy') AND 
+  (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CLASS' IN TYPEOF(gr\group_relationship.related_group)) OR 
+  NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CLASS' IN TYPEOF(gr\group_relationship.relating_group))) )) = 0;
+END_RULE;
+
+RULE restrict_group_relationship_for_specification_category FOR (group_relationship);
+
+WHERE
+	WR1 : SIZEOF( QUERY( gr <* group_relationship | 
+  (gr.name = 'specification category hierarchy') AND 
+  (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_CONCEPT_FEATURE_CATEGORY' IN TYPEOF(gr.related_group)) 
+  OR NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_CONCEPT_FEATURE_CATEGORY' IN TYPEOF(gr.relating_group))) )) = 0;
+END_RULE;
+
+RULE restrict_language_assignment_per_attribute FOR (attribute_language_assignment);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( ala1 <* attribute_language_assignment |
+	SIZEOF(QUERY( it <* ala1.items |
+	   SIZEOF ( QUERY ( ala2 <* USEDIN ( it ,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS' ) | 
+		( ala1\attribute_classification_assignment.attribute_name = ala2\attribute_classification_assignment.attribute_name ) AND 
+		( ala1\attribute_classification_assignment.assigned_class :=: ala2\attribute_classification_assignment.assigned_class )
+		 )) >1 
+	   )) >0 
+	)) =0;
+END_RULE;
+
+RULE restrict_part_occurrence FOR (product_definition);
+    LOCAL
+      part_occurrences: SET OF product_definition := QUERY(pd <* product_definition | 
+	    ( pd.frame_of_reference.name = 'part occurrence' ));
+    END_LOCAL;
+WHERE
+	WR1 : SIZEOF ( QUERY ( pd <* part_occurrences | 
+	    ( NOT( pd.name IN 
+        ['single instance' , 'selected instance' ,'quantified instance' , 'specified instance' ] ) ) ) ) = 0;
+	WR2 : SIZEOF ( QUERY ( pd <* part_occurrences | 
+ 	    (SIZEOF ( QUERY ( pdr <* USEDIN ( pd ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRODUCT_DEFINITION_RELATIONSHIP.RELATED_PRODUCT_DEFINITION' ) | 
+	    pdr.name = 'definition usage' ) ) <>1 ) AND 
+        ( SIZEOF ( QUERY ( cd <* USEDIN ( pd , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONFIGURATION_DESIGN.DESIGN' ) | 
+        ( cd.name = 'occurrence usage definition' ) AND 
+        ( NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRODUCT_IDENTIFICATION' IN TYPEOF( cd.configuration ) ) ) ) ) <>1 ) ) ) = 0;
+	WR3 : SIZEOF ( QUERY ( pd <* part_occurrences |  
+        (SIZEOF ( QUERY ( cd <* USEDIN ( pd , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'PRODUCT_DEFINITION_RELATIONSHIP.RELATED_PRODUCT_DEFINITION' ) |
+        ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +'PRODUCT_DEFINITION_USAGE' IN TYPEOF ( cd ) ) ) ) = 0 )AND
+        ( SIZEOF ( USEDIN ( pd , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRODUCT_DEFINITION_OCCURRENCE_RELATIONSHIP.OCCURRENCE' ) ) = 0 ) ) ) = 0;
+	WR4 : SIZEOF ( QUERY ( pd <* part_occurrences | 
+        ( pd.name = 'selected instance' ) AND 
+        NOT valid_selected_instance_representation(pd) ))=0;
+	WR5 : SIZEOF ( QUERY ( pd <* part_occurrences | 
+        ( pd.name = 'quantified instance' ) AND 
+        ( SIZEOF ( QUERY (ppd <* USEDIN ( pd , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +'PROPERTY_DEFINITION.DEFINITION' ) |
+        ( ppd.name ='occurrence quantity' ) AND 
+        ( SIZEOF ( QUERY ( pdr <*USEDIN ( ppd , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION' ) | (
+        pdr.used_representation.name = 'quantity' ) AND 
+        (SIZEOF ( pdr.used_representation.items ) = 1 ) AND 
+        (SIZEOF ( QUERY ( i <* pdr.used_representation.items | 
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'MEASURE_REPRESENTATION_ITEM' IN TYPEOF ( i ) ) AND
+        ( i.name = 'quantity measure' ) ) ) = 1)))= 1 )))= 0 )))= 0;
+	WR6 : SIZEOF ( QUERY ( pd <* part_occurrences | 
+        ( pd.name = 'specified instance' ) AND 
+        ( SIZEOF ( QUERY (
+        pdor <* USEDIN ( pd , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +'PRODUCT_DEFINITION_OCCURRENCE_RELATIONSHIP.OCCURRENCE' ) | 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +'SPECIFIED_HIGHER_USAGE_OCCURRENCE' IN TYPEOF ( pdor.occurrence_usage ) ) ) = 0 ) ) ) = 0;
+END_RULE;
+
+RULE restrict_part_occurrence_category FOR (product_definition);
+    LOCAL
+      part_occurrences: SET OF product_definition := QUERY( pd <* product_definition |(
+        pd.frame_of_reference.name = 'part occurrence'));
+    END_LOCAL;
+WHERE
+	WR1 : SIZEOF( QUERY( pd <* part_occurrences | 
+        (SIZEOF( QUERY( prpc <* USEDIN(pd.formation.of_product, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') | 
+        prpc.name IN ['part','raw material','tool'] )) = 0 ) )) = 0;
+END_RULE;
+
+RULE restrict_product_definitions_for_base_element FOR (product_definition_relationship);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pdr <* product_definition_relationship |
+       ( pdr. name = 'solution alternative definition' ) AND 
+       ( NOT( pdr. relating_product_definition.frame_of_reference.name
+        IN [ 'alternative definition' , 'functional definition' , 'conceptual definition' ] ) OR 
+       ( pdr.related_product_definition.frame_of_reference.name<>'alternative definition' ) ) ) ) =0;
+END_RULE;
+
+RULE restrict_product_definitions_for_collection FOR (product_definition_relationship);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pdr <* product_definition_relationship |
+       ( pdr. name = 'collection membership' ) AND 
+       ( ( pdr.relating_product_definition.frame_of_reference.name<>'part definition' ) OR 
+       ( pdr.related_product_definition.frame_of_reference.name<>'part occurrence' ) OR 
+       ( SIZEOF ( QUERY ( pdca <* USEDIN (pdr.relating_product_definition ,
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.PRODUCT_DEFINITION_CONTEXT_ASSOCIATION.DEFINITION') | 
+       ( pdca.role.name = 'part definition type' ) AND 
+       ( pdca.frame_of_reference.name = 'collection definition' ) )) =0 ) ) ) ) =0;
+END_RULE;
+
+RULE restrict_product_definitions_for_definition_usage FOR (product_definition_relationship);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pdr <* product_definition_relationship |
+        ( pdr.name = 'definition usage' ) AND 
+        ( ( pdr.relating_product_definition.frame_of_reference.name<> 'part definition' ) OR 
+        ( pdr.related_product_definition.frame_of_reference.name<>'part occurrence' )))) =0;
+END_RULE;
+
+RULE restrict_product_definitions_for_design_constraint_association FOR (product_definition_relationship);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pdr <* product_definition_relationship |
+        ( pdr. name = 'design constraint association' ) AND 
+	    ( (pdr. relating_product_definition.frame_of_reference.name<>'design constraint definition' ) OR 
+	    NOT ( pdr.related_product_definition.frame_of_reference.name IN 
+	    ['alternative definition' , 'functional definition' ,'conceptual definition' ] ) ) ) ) =0;
+END_RULE;
+
+RULE restrict_product_definitions_for_part_definition_relationship FOR (product_definition_relationship);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pdr <* product_definition_relationship |
+        ( pdr.name IN [ 'geometrical relationship' , 'definition replacement' ] ) AND 
+	    ( ( pdr.relating_product_definition.frame_of_reference.name <>'part definition' ) OR 
+        ( pdr.related_product_definition.frame_of_reference.name <>'part definition' ) ) ) ) =0;
+END_RULE;
+
+RULE restrict_representation_for_surface_condition FOR (property_definition_representation);
+
+WHERE
+	WR1 : SIZEOF(QUERY(pdr <* property_definition_representation | 
+        NOT surface_condition_correlation(pdr.definition, pdr.used_representation) ))=0;
+END_RULE;
+
+RULE restrict_treatment_result FOR (representation);
+    LOCAL
+      treatment_results: SET OF representation := [];
+    END_LOCAL;
+    treatment_results:= QUERY( r <* representation | 
+	  (r.name = 'treatment result') );
+WHERE
+	WR1 : (SIZEOF( QUERY( r <* treatment_results | (SIZEOF(r.items) > 2) )) = 0) AND
+        (SIZEOF( QUERY( r <* treatment_results |
+        (SIZEOF( QUERY( i <* r.items | 
+         NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF(i)) )) > 0) )) = 0);
+	WR2 : SIZEOF( QUERY( r <* treatment_results | 
+        (SIZEOF( QUERY( i <* r.items | i.name = 'result' )) = 0) )) = 0;
+	WR3 : SIZEOF( QUERY( r <* treatment_results | 
+        (SIZEOF( QUERY( i <* r.items | i.name = 'purpose' )) > 1) )) = 0;
+END_RULE;
+
+RULE selected_instance_usage_requires_representation FOR (assembly_component_usage);
+    LOCAL
+      selected_instance_usages: SET OF assembly_component_usage := QUERY( acr <* assembly_component_usage|
+        (acr.name = 'selected instance usage'));
+    END_LOCAL;
+WHERE
+	WR1 : SIZEOF ( QUERY ( acr <* selected_instance_usages | 
+        NOT valid_selected_instance_representation(acr) ))=0;
+END_RULE;
+
+RULE solution_definition_requires_solution_category FOR (product_definition);
+    LOCAL
+      solution_definitions: SET OF product_definition := [];
+    END_LOCAL;
+      solution_definitions :=  QUERY( pd <* product_definition |
+        (pd.frame_of_reference.name = 'alternative definition'));
+WHERE
+	WR1 : SIZEOF( QUERY( pd <* solution_definitions | 
+        (SIZEOF( QUERY( prpc <* USEDIN(pd.formation.of_product, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') | 
+	     prpc.name = 'alternative solution')) = 0 ) )) = 0;
+END_RULE;
+
+RULE stock_material_reference FOR (percentage_ply_definition, make_from_usage_option, product_related_product_category);
+    LOCAL
+      i,j,k :  INTEGER;
+      dkuhr :  LOGICAL;
+      nmfuo :  INTEGER;
+      nprpc :  INTEGER;
+      rp     :  product;
+    END_LOCAL;
+    dkuhr := TRUE;
+    REPEAT i:= LOINDEX (percentage_ply_definition) TO
+               HIINDEX (percentage_ply_definition);
+      nmfuo := 0;  
+      REPEAT j:= LOINDEX (make_from_usage_option) TO 
+                 HIINDEX (make_from_usage_option);
+        IF (percentage_ply_definition[i] = 
+          make_from_usage_option[j].relating_product_definition) THEN
+          rp := make_from_usage_option[j].related_product_definition.
+                formation.of_product;
+          nprpc := 0;
+          REPEAT k:= LOINDEX (product_related_product_category) TO
+                     HIINDEX (product_related_product_category);
+            IF ((rp IN product_related_product_category[k].products) AND
+                (product_related_product_category[k].name IN 
+                ['anisotropic material', 'isotropic material', 'stock core',
+                 'filament assembly', 'discontinuous fiber assembly'])) THEN
+                nprpc := nprpc + 1;
+            END_IF;
+          END_REPEAT;
+          IF (nprpc = 1) THEN
+            nmfuo := nmfuo + 1;
+          ELSE
+            dkuhr := FALSE;
+            ESCAPE;
+          END_IF;
+        END_IF;
+      END_REPEAT;
+      IF (dkuhr = FALSE) THEN
+        ESCAPE; 
+      END_IF;
+      IF(nmfuo = 0) THEN
+        dkuhr := FALSE;
+        ESCAPE;
+      END_IF;
+    END_REPEAT;
+WHERE
+	WR1 : dkuhr;
+END_RULE;
+
+RULE styled_curve FOR (styled_item);
+
+WHERE
+	WR1 : SIZEOF( QUERY( si <* styled_item | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE' IN TYPEOF (si.item)) AND (SIZEOF (QUERY (psa <* si.styles | (SIZEOF (QUERY (cs <* psa.styles | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE' IN TYPEOF (cs)) )) > 0) )) <> 1) )) = 0;
+END_RULE;
+
+RULE subtype_exclusiveness_geometric_tolerance FOR (geometric_tolerance);
+
+WHERE
+	WR1 : SIZEOF(QUERY (gt <* geometric_tolerance | NOT (type_check_function(gt, ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANGULARITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCULAR_RUNOUT_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COAXIALITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONCENTRICITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CYLINDRICITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FLATNESS_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE_PROFILE_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PARALLELISM_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PERPENDICULARITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITION_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ROUNDNESS_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRAIGHTNESS_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_PROFILE_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SYMMETRY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TOTAL_RUNOUT_TOLERANCE'] , 3)))) = 0;
+END_RULE;
+
+RULE subtype_exclusiveness_representation_item FOR (representation_item);
+
+WHERE
+	WR1 : SIZEOF(QUERY (cri <* representation_item | 
+      NOT (type_check_function(cri,['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM',
+                                    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VALUE_REPRESENTATION_ITEM',
+                                    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOUND_REPRESENTATION_ITEM'] , 3)))) = 0;
+END_RULE;
+
+RULE subtype_mandatory_geometric_tolerance FOR (geometric_tolerance);
+
+WHERE
+	WR1 : SIZEOF(QUERY (gt <* geometric_tolerance | NOT (type_check_function(gt, ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANGULARITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCULAR_RUNOUT_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COAXIALITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONCENTRICITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CYLINDRICITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FLATNESS_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE_PROFILE_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PARALLELISM_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PERPENDICULARITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITION_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ROUNDNESS_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRAIGHTNESS_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_PROFILE_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SYMMETRY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TOTAL_RUNOUT_TOLERANCE'] , 0)))) = 0;
+END_RULE;
+
+RULE text_font_usage FOR (externally_defined_text_font, pre_defined_text_font);
+
+WHERE
+	WR1 : SIZEOF (QUERY (pdtf <* pre_defined_text_font | SIZEOF (USEDIN (pdtf, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL.FONT')) = 0 )) = 0;
+	WR2 : SIZEOF (QUERY (edtf <* externally_defined_text_font | SIZEOF (USEDIN (edtf, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL.FONT')) = 0 )) = 0;
+END_RULE;
+
+RULE thickness_laminate_table_component_select FOR (thickness_laminate_definition, next_assembly_usage_occurrence, product_related_product_category);
+    LOCAL
+      i,j,k :  INTEGER;
+      dkuhr :  LOGICAL;
+      nnauo :  INTEGER;
+      nprpc :  INTEGER;
+      rp    :  product;
+    END_LOCAL;
+    dkuhr := TRUE;
+    REPEAT i:= LOINDEX (thickness_laminate_definition) TO
+               HIINDEX (thickness_laminate_definition);
+      nnauo := 0;  
+      REPEAT j:= LOINDEX (next_assembly_usage_occurrence) TO 
+                 HIINDEX (next_assembly_usage_occurrence);
+        IF (thickness_laminate_definition[i] = 
+          next_assembly_usage_occurrence[j].relating_product_definition) THEN
+          rp := next_assembly_usage_occurrence[j].related_product_definition.
+                formation.of_product;
+          nprpc := 0;
+          REPEAT k:= LOINDEX (product_related_product_category) TO
+                     HIINDEX (product_related_product_category);
+            IF ((rp IN product_related_product_category[k].products) AND
+                (product_related_product_category[k].name IN 
+                 ['ply', 'filament laminate', 'processed core'])) THEN
+                nprpc := nprpc + 1;
+            END_IF;
+          END_REPEAT;
+          IF (nprpc = 1) THEN
+            nnauo := nnauo + 1;
+          ELSE
+            dkuhr := FALSE;
+            ESCAPE;
+          END_IF;
+        END_IF;
+      END_REPEAT;
+      IF (dkuhr = FALSE) THEN
+        ESCAPE;
+      END_IF;
+      IF (nnauo <> 1) THEN
+        dkuhr := FALSE;
+        ESCAPE;
+      END_IF;
+    END_REPEAT;
+WHERE
+	WR1 : dkuhr;
+END_RULE;
+
+RULE validate_dependently_instantiable_entity_data_types FOR (action_method_role, annotation_text, attribute_value_role, auxiliary_geometric_representation_item, binary_numeric_expression, boolean_expression, bounded_curve, bounded_surface, cartesian_transformation_operator, comparison_expression, concept_feature_relationship, concept_feature_relationship_with_condition, connected_edge_set, document_usage_constraint, edge_blended_solid, effectivity_context_role, event_occurrence_role, explicit_procedural_representation_item_relationship, expression, founded_item, generic_expression, generic_variable, indirectly_selected_elements, interval_expression, literal_number, local_time, loop, modified_solid_with_placed_configuration, multiple_arity_boolean_expression, multiple_arity_generic_expression, multiple_arity_numeric_expression, numeric_expression, one_direction_repeat_factor, oriented_open_shell, oriented_path, positioned_sketch, procedural_representation, procedural_representation_sequence, product_definition_context_role, product_definition_effectivity, runout_zone_orientation, simple_boolean_expression, simple_generic_expression, simple_numeric_expression, solid_with_depression, solid_with_hole, solid_with_pocket, solid_with_protrusion, solid_with_shape_element_pattern, solid_with_slot, swept_area_solid, symbol_target, tolerance_zone_form, two_direction_repeat_factor, unary_generic_expression, unary_numeric_expression, user_selected_elements, variational_representation_item, view_volume);
+LOCAL
+  number_of_input_instances : INTEGER;
+  previous_in_chain : LIST OF GENERIC := [];
+  set_of_input_types : SET OF STRING := [];
+  all_instances : SET OF GENERIC := [];
+END_LOCAL;
+
+  all_instances := all_instances + action_method_role + annotation_text + attribute_value_role + auxiliary_geometric_representation_item + binary_numeric_expression + boolean_expression + bounded_curve + bounded_surface + cartesian_transformation_operator + comparison_expression + concept_feature_relationship + concept_feature_relationship_with_condition + connected_edge_set + document_usage_constraint + edge_blended_solid + effectivity_context_role + event_occurrence_role + explicit_procedural_representation_item_relationship + expression + founded_item + generic_expression + generic_variable + indirectly_selected_elements + interval_expression + literal_number + local_time + loop + modified_solid_with_placed_configuration + multiple_arity_boolean_expression + multiple_arity_generic_expression + multiple_arity_numeric_expression + numeric_expression + one_direction_repeat_factor + oriented_open_shell + oriented_path + positioned_sketch + procedural_representation + procedural_representation_sequence + product_definition_context_role + product_definition_effectivity + runout_zone_orientation + simple_boolean_expression + simple_generic_expression + simple_numeric_expression + solid_with_depression + solid_with_hole + solid_with_pocket + solid_with_protrusion + solid_with_shape_element_pattern + solid_with_slot + swept_area_solid + symbol_target + tolerance_zone_form + two_direction_repeat_factor + unary_generic_expression + unary_numeric_expression + user_selected_elements + variational_representation_item + view_volume;--<make a union of all implicit populations of the FOR-clause>
+number_of_input_instances := SIZEOF(all_instances);
+(* Collect all type strings of all FOR instances into one set. *)
+REPEAT i:=1 TO number_of_input_instances;
+  set_of_input_types := set_of_input_types + TYPEOF(all_instances[i]);
+END_REPEAT;
+WHERE
+	WR1 : dependently_instantiated(all_instances, set_of_input_types,
+                                previous_in_chain);
+END_RULE;
+
+FUNCTION acyclic
+	(arg1: generic_expression; arg2: SET [0:?] OF generic_expression) : BOOLEAN;
+LOCAL
+	result: BOOLEAN := TRUE;
+END_LOCAL;
+
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SIMPLE_GENERIC_EXPRESSION'
+	IN TYPEOF (arg1)) 
+THEN
+	RETURN (TRUE);
+END_IF;
+
+IF arg1 IN arg2 
+THEN 
+	RETURN (FALSE);
+END_IF;
+
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.UNARY_GENERIC_EXPRESSION' 
+	IN TYPEOF (arg1) 
+THEN 
+	RETURN 
+	(acyclic(arg1\unary_generic_expression.operand,arg2+[arg1]));
+END_IF;
+
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BINARY_GENERIC_EXPRESSION' 
+	IN TYPEOF (arg1) 
+THEN 
+	RETURN 
+	(acyclic(arg1\binary_generic_expression.operands[1],arg2+[arg1])
+	AND
+	acyclic(arg1\binary_generic_expression.operands[2],arg2+[arg1]));
+END_IF;
+
+IF 
+'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MULTIPLE_ARITY_GENERIC_EXPRESSION' 
+	IN TYPEOF (arg1) 
+THEN 
+	result := TRUE;
+	REPEAT i := 1 TO 
+			SIZEOF (arg1\multiple_arity_generic_expression.operands);
+		result := result AND
+		acyclic(arg1\multiple_arity_generic_expression.operands[i], arg2+[arg1]);
+	END_REPEAT;
+
+	RETURN (result);
+END_IF;
+	RETURN (result);
+END_FUNCTION;
+
+FUNCTION acyclic_composite_text
+	(start_composite: composite_text; child_text: SET [1:?] OF text_or_character) : LOGICAL;
+    LOCAL
+      i : INTEGER;
+      local_composite_text : SET [0:?] OF composite_text;
+      local_annotation_text : SET [0:?] OF annotation_text;
+      local_children : SET [0:?] OF text_or_character;
+    END_LOCAL;
+
+    local_composite_text := QUERY (child <* child_text |
+                          ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'
+                           IN TYPEOF (child)));
+
+    IF (SIZEOF (local_composite_text) > 0) 
+      THEN
+        REPEAT i := 1 TO HIINDEX (local_composite_text);
+          IF (start_composite :=: local_composite_text[i]) 
+            THEN
+              RETURN (FALSE);
+          END_IF;
+        END_REPEAT;
+    END_IF;
+
+    local_children := child_text;
+
+    IF (SIZEOF (local_composite_text)) > 0 THEN
+      REPEAT i := 1 TO HIINDEX (local_composite_text);
+        local_children := local_children +
+                          local_composite_text[i].collected_text;
+      END_REPEAT;
+    END_IF;
+
+    local_annotation_text := QUERY (child <* child_text |
+                            ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT'
+                             IN TYPEOF (child)));
+
+    IF (SIZEOF (local_annotation_text) > 0) THEN
+      REPEAT i := 1 TO HIINDEX (local_annotation_text);
+        local_children := local_children +
+        QUERY (item <* local_annotation_text[i]\mapped_item.
+                       mapping_source.mapped_representation.items |
+          SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT',
+                  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'] *
+                  TYPEOF(item)) > 0);
+      END_REPEAT;
+    END_IF;
+
+    IF (local_children :<>: child_text) THEN
+      RETURN (acyclic_composite_text (start_composite, local_children));
+    ELSE
+      RETURN (TRUE);
+    END_IF;
+END_FUNCTION;
+
+FUNCTION acyclic_curve_replica
+	(rep: curve_replica; parent: curve) : BOOLEAN;
+IF NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA') IN TYPEOF(parent)) THEN
+      RETURN (TRUE);
+   END_IF;
+ (* Return TRUE if the parent is not of type curve_replica *)
+   IF (parent :=: rep) THEN
+      RETURN (FALSE);
+  (* Return FALSE if the parent is the same curve_replica, otherwise,
+   call function again with the parents own parent_curve.     *)
+    ELSE
+    RETURN(acyclic_curve_replica(rep,
+               parent\curve_replica.parent_curve));
+    END_IF;
+END_FUNCTION;
+
+FUNCTION acyclic_mapped_item_usage
+	(rep: representation) : BOOLEAN;
+  LOCAL
+    items : SET OF representation_item;
+  END_LOCAL;
+
+  items := QUERY (item <* rep.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (item));
+  IF SIZEOF (items) = 0
+  THEN 
+    RETURN (FALSE);
+  ELSE 
+    REPEAT i := 1 TO HIINDEX (items);
+      IF items[i]\mapped_item.mapping_source.mapped_representation :=: rep
+      THEN 
+        RETURN (TRUE);
+      ELSE 
+        RETURN (acyclic_mapped_item_usage(items[i]\
+                  mapped_item.mapping_source.mapped_representation));
+      END_IF;
+    END_REPEAT;
+  RETURN (FALSE);
+  END_IF;
+END_FUNCTION;
+
+FUNCTION acyclic_mapped_representation
+	(mi: mapped_item) : BOOLEAN;
+    LOCAL
+      rms : SET OF representation_map;
+      mis : SET OF mapped_item;
+      rs1, rs2 : SET OF representation;
+    END_LOCAL;
+ 
+    rs1 := using_representations(mi);
+    rs2 := [];
+    -- loop as long as there are elements in rs1
+    REPEAT WHILE SIZEOF(rs1) > 0; 
+      REPEAT i := 1 TO HIINDEX(rs1);
+        -- Determine the set of representation_map that reference the parent_set
+        rms := bag_to_set(USEDIN(rs1[i], 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION_MAP.MAPPED_REPRESENTATION'));
+        IF SIZEOF(rms) > 0 THEN
+          REPEAT j := 1 TO HIINDEX(rms);
+            mis := bag_to_set(USEDIN(rms[i], 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM.MAPPING_SOURCE'));
+            IF SIZEOF(mis) > 0 THEN
+              REPEAT j := 1 TO HIINDEX(mis);
+                -- check mis members for instance equal with mi. If so then there is a cycle
+                IF mis[i] :=: mi THEN
+                  RETURN (FALSE);
+                END_IF;
+                rs2 := rs2 + using_representations(mis[i]);
+              END_REPEAT;
+            END_IF;
+          END_REPEAT;
+        END_IF;
+      END_REPEAT;
+      rs1 := rs2;
+      rs2 := [];
+    END_REPEAT;
+    RETURN (TRUE);
+END_FUNCTION;
+
+FUNCTION acyclic_point_replica
+	(rep: point_replica; parent: point) : BOOLEAN;
+IF NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_REPLICA') IN TYPEOF(parent)) THEN
+      RETURN (TRUE);
+   END_IF;
+ (* Return TRUE if the parent is not of type point_replica *)
+   IF (parent :=: rep) THEN
+      RETURN (FALSE);
+  (* Return FALSE if the parent is the same point_replica, otherwise,
+   call function again with the parents own parent_pt.     *)
+    ELSE RETURN(acyclic_point_replica(rep, parent\point_replica.parent_pt));
+    END_IF;
+END_FUNCTION;
+
+FUNCTION acyclic_product_definition_relationship
+	(relation: product_definition_relationship; relatives: SET [1:?] OF product_definition; specific_relation: STRING) : BOOLEAN;
+    LOCAL
+      x : SET OF product_definition_relationship;
+    END_LOCAL;
+
+    IF relation.relating_product_definition IN relatives THEN
+      RETURN (FALSE);
+    END_IF;
+    x := QUERY(pd <* bag_to_set(USEDIN(relation.relating_product_definition, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRODUCT_DEFINITION_RELATIONSHIP.' + 'RELATED_PRODUCT_DEFINITION')) | specific_relation IN TYPEOF(pd));
+    REPEAT i := 1 TO HIINDEX(x);
+      IF NOT acyclic_product_definition_relationship(x[i], relatives + relation.relating_product_definition, specific_relation) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_REPEAT;
+    RETURN (TRUE);
+END_FUNCTION;
+
+FUNCTION acyclic_representation_relationship
+	(relation: representation_relationship; relatives: SET [1:?] OF representation; specific_relation: STRING) : BOOLEAN;
+    LOCAL
+      x : SET OF representation_relationship;
+    END_LOCAL;
+
+    IF relation.rep_1 IN relatives THEN
+      RETURN (FALSE);
+    END_IF;
+    x := QUERY(r <* bag_to_set(USEDIN(relation.rep_1, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION_RELATIONSHIP.' + 'REP_2')) | specific_relation IN TYPEOF(r));
+    REPEAT i := 1 TO HIINDEX(x);
+      IF NOT acyclic_representation_relationship(x[i], relatives + relation.rep_1, specific_relation) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_REPEAT;
+    RETURN (TRUE);
+END_FUNCTION;
+
+FUNCTION acyclic_solid_replica
+	(rep: solid_replica; parent: solid_model) : BOOLEAN;
+IF NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_REPLICA') IN TYPEOF(parent)) THEN
+      RETURN (TRUE);
+   END_IF;
+ (* Return TRUE if the parent is not of type solid_replica. *)
+   IF (parent :=: rep) THEN
+      RETURN (FALSE);
+  (* Return FALSE if the parent is the same solid_replica, otherwise,
+   call function again with the parents own parent_solid.     *)
+    ELSE RETURN(acyclic_solid_replica(rep,
+                      parent\solid_replica.parent_solid));
+    END_IF;
+END_FUNCTION;
+
+FUNCTION acyclic_surface_replica
+	(rep: surface_replica; parent: surface) : BOOLEAN;
+IF NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_REPLICA') IN TYPEOF(parent)) THEN
+      RETURN (TRUE);
+   END_IF;
+ (* Return TRUE if the parent is not of type surface_replica *)
+   IF (parent :=: rep) THEN
+      RETURN (FALSE);
+  (* Return FALSE if the parent is the same surface_replica, otherwise,
+   call function again with the parents own parent_surface.     *)
+    ELSE RETURN(acyclic_surface_replica(rep,
+                   parent\surface_replica.parent_surface));
+    END_IF;
+END_FUNCTION;
+
+FUNCTION advanced_face_properties
+	(testface: face) : BOOLEAN;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF(testface) THEN
+    RETURN (TRUE);
+END_IF;
+(* if testface is a subface recursively test the parent_face,
+return FALSE for all other types of face *)
+IF  ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBFACE' IN TYPEOF(testface)) THEN
+     RETURN(advanced_face_properties(testface\subface.parent_face));
+   ELSE RETURN (FALSE);
+END_IF;
+END_FUNCTION;
+
+FUNCTION aspect_ratio
+	(p: planar_box) : positive_ratio_measure;
+IF (p.size_in_x > 0.) AND (p.size_in_y > 0.) THEN
+      RETURN (p.size_in_x / p.size_in_y);
+    ELSE
+      RETURN (?);
+    END_IF;
+END_FUNCTION;
+
+FUNCTION associated_surface
+	(arg: pcurve_or_surface) : surface;
+   LOCAL
+     surf : surface;
+   END_LOCAL;
+   
+   IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(arg) THEN
+     surf := arg\pcurve.basis_surface;
+   ELSE
+     surf := arg;
+   END_IF;
+   RETURN(surf);
+END_FUNCTION;
+
+FUNCTION bag_to_set
+	(the_bag: BAG [0:?] OF GENERIC: intype) : SET [0:?] OF GENERIC: intype;
+    LOCAL
+      the_set : SET OF GENERIC:intype := [];
+    END_LOCAL;
+
+    IF SIZEOF(the_bag) > 0 THEN
+      REPEAT i := 1 TO HIINDEX(the_bag);
+        the_set := the_set + the_bag[i];
+      END_REPEAT;
+    END_IF;
+    RETURN (the_set);
+END_FUNCTION;
+
+FUNCTION base_axis
+	(dim: INTEGER; axis1: direction; axis2: direction; axis3: direction) : LIST [2:3] OF direction;
+  LOCAL
+    u      : LIST [2:3] OF direction;
+    factor : REAL;
+    d1, d2 : direction;
+  END_LOCAL;
+  
+  IF (dim = 3) THEN
+    d1 := NVL(normalise(axis3),  dummy_gri || direction([0.0,0.0,1.0]));
+    d2 := first_proj_axis(d1,axis1);
+    u := [d2, second_proj_axis(d1,d2,axis2), d1];
+  ELSE
+     IF EXISTS(axis1) THEN
+      d1 := normalise(axis1);
+      u := [d1, orthogonal_complement(d1)];
+      IF EXISTS(axis2) THEN
+        factor := dot_product(axis2,u[2]);
+        IF (factor < 0.0) THEN
+          u[2].direction_ratios[1] := -u[2].direction_ratios[1];
+          u[2].direction_ratios[2] := -u[2].direction_ratios[2];
+        END_IF;
+      END_IF;
+    ELSE
+      IF EXISTS(axis2) THEN
+        d1 := normalise(axis2);
+        u := [orthogonal_complement(d1), d1]; 
+        u[1].direction_ratios[1] := -u[1].direction_ratios[1];
+        u[1].direction_ratios[2] := -u[1].direction_ratios[2];
+      ELSE
+        u := [dummy_gri || direction([1.0, 0.0]), dummy_gri ||
+                                                direction([0.0, 1.0])];
+      END_IF;
+    END_IF;
+  END_IF;
+  RETURN(u);
+END_FUNCTION;
+
+FUNCTION boolean_choose
+	(b: BOOLEAN; choice1: GENERIC: item; choice2: GENERIC: item) : GENERIC: item;
+IF b THEN
+       RETURN (choice1);
+     ELSE
+       RETURN (choice2);
+     END_IF;
+END_FUNCTION;
+
+FUNCTION build_2axes
+	(ref_direction: direction) : LIST [2:2] OF direction;
+   LOCAL
+     d : direction := NVL(normalise(ref_direction),
+                          dummy_gri || direction([1.0,0.0]));
+   END_LOCAL;
+
+   RETURN([d, orthogonal_complement(d)]);
+END_FUNCTION;
+
+FUNCTION build_axes
+	(axis: direction; ref_direction: direction) : LIST [3:3] OF direction;
+     LOCAL
+       d1, d2 : direction;
+     END_LOCAL;
+    d1 := NVL(normalise(axis), dummy_gri || direction([0.0,0.0,1.0]));
+    d2 := first_proj_axis(d1, ref_direction);
+    RETURN([d2, normalise(cross_product(d1,d2))\vector.orientation, d1]);
+END_FUNCTION;
+
+FUNCTION categories_of_product
+	(obj: product) : SET [0:?] OF STRING;
+LOCAL
+  category_assignments: BAG OF product_category;
+  categories: SET OF STRING:=[];
+END_LOCAL;
+category_assignments := USEDIN(obj, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS');
+REPEAT i := LOINDEX(category_assignments) TO HIINDEX(category_assignments) BY 1;
+  categories := categories + category_assignments[i].name;
+END_REPEAT;
+RETURN(categories);
+END_FUNCTION;
+
+FUNCTION cc_design_person_and_organization_correlation
+	(e: cc_design_person_and_organization_assignment) : BOOLEAN;
+    LOCAL
+      po_role : STRING;
+    END_LOCAL;
+      po_role := e\person_and_organization_assignment.role.name;
+    CASE po_role OF
+      'request_recipient'      : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'CHANGE_REQUEST',
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'START_REQUEST'] *
+                                 TYPEOF (x)) = 1))
+                                 THEN RETURN(FALSE);
+                               END_IF;
+      'initiator'              : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'CHANGE_REQUEST',
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'START_REQUEST',
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'START_WORK',
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'CHANGE'] *
+                                 TYPEOF (x)) = 1))
+                                 THEN RETURN(FALSE);
+                               END_IF;
+      'creator'                : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'PRODUCT_DEFINITION_FORMATION',
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'PRODUCT_DEFINITION'] *
+                                 TYPEOF (x)) = 1))
+                                 THEN RETURN (FALSE);
+                               END_IF;
+      'part_supplier'          : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'PRODUCT_DEFINITION_FORMATION'
+                                 IN TYPEOF (x)))
+                                 THEN RETURN(FALSE);
+                               END_IF;
+      'design_supplier'        : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'PRODUCT_DEFINITION_FORMATION'
+                                 IN TYPEOF (x)))
+                                 THEN RETURN(FALSE);
+                               END_IF;
+      'design_owner'           : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT'
+                                 IN TYPEOF (x)))
+                                 THEN RETURN(FALSE);
+                               END_IF;
+      'configuration_manager'  : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'CONFIGURATION_ITEM'
+                                 IN TYPEOF (x)))
+                                 THEN RETURN(FALSE);
+                               END_IF;
+      'contractor'             : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONTRACT'
+                                 IN TYPEOF (x)))
+                                 THEN RETURN(FALSE);
+                               END_IF;
+      'classification_officer' : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'SECURITY_CLASSIFICATION'
+                                 IN TYPEOF (x))) THEN
+                                 RETURN(FALSE);
+                               END_IF;
+    OTHERWISE : RETURN(TRUE);
+  END_CASE;
+  RETURN (TRUE);
+END_FUNCTION;
+
+FUNCTION check_continuous_edges
+	(edges: LIST [0:?] OF  UNIQUE edge_curve) : BOOLEAN;
+  LOCAL
+    i           : INTEGER;
+    next_vertex : vertex;
+  END_LOCAL;
+
+  -- first check whether there is only one edge in the list: in this
+  -- case there is no connectivity to be checked.
+
+  IF (SIZEOF(edges) = 1)
+  THEN RETURN(TRUE);
+  END_IF;
+
+  -- otherwise, establish the matching vertices of edges 1 and 2 in 
+  -- the list, and determine the vertex of edge 2 to which edge 3, 
+  -- must be connected, if there are more than two edges in the list.
+
+  IF ((edges[2].edge_start :=: edges[1].edge_end)
+    XOR (edges[2].edge_start :=: edges[1].edge_start))
+  THEN next_vertex := edges[2].edge_end;
+  ELSE 
+    IF ((edges[2].edge_end :=: edges[1].edge_end)
+      XOR (edges[2].edge_end :=: edges[1].edge_start))
+    THEN next_vertex := edges[2].edge_start;
+    ELSE RETURN(FALSE); -- no match between any vertices of edges 1 and 2 
+    END_IF;
+  END_IF;
+
+  -- exit if there are only two edges and they are connected
+
+  IF (SIZEOF(edges) = 2)
+  THEN RETURN(TRUE);
+  END_IF;
+
+  -- otherwise, check that any remaining edges are connected in list order.
+
+  REPEAT i := 3 TO HIINDEX(edges);
+    IF (edges[i].edge_start :=: next_vertex)
+    THEN next_vertex := edges[i].edge_end;
+    ELSE
+      IF (edges[i].edge_end :=: next_vertex)
+      THEN next_vertex := edges[i].edge_start;
+      ELSE RETURN(FALSE); -- no match is found.
+      END_IF;
+    END_IF; 
+  END_REPEAT;
+  RETURN(TRUE);
+END_FUNCTION;
+
+FUNCTION check_text_alignment
+	(ct: composite_text) : BOOLEAN;
+  LOCAL
+    a : SET OF text_alignment := [];
+  END_LOCAL;
+
+  -- create a set of all the alignments
+  REPEAT i := 1 TO HIINDEX (ct.collected_text);
+    a := a + [ct.collected_text[i]\text_literal.alignment];
+  END_REPEAT;
+
+  -- if there is more than one element in the set
+  -- then not all alignments were the same
+  RETURN (SIZEOF(a) = 1);
+END_FUNCTION;
+
+FUNCTION check_text_font
+	(ct: composite_text) : BOOLEAN;
+  LOCAL
+    f : SET OF font_select := [];
+  END_LOCAL;
+
+  -- build a set of all the fonts
+  REPEAT i := 1 TO HIINDEX (ct.collected_text);
+    f := f + [ct.collected_text[i]\text_literal.font];
+  END_REPEAT;
+
+  -- if there is more than one element in the set
+  -- then not all fonts were the same
+  RETURN (SIZEOF(f) <= 1);
+END_FUNCTION;
+
+FUNCTION class_assignment_is_valid
+	(aia: applied_classification_assignment) : BOOLEAN;
+LOCAL
+  item: classification_item;
+  role: classification_role;
+END_LOCAL;
+
+role:= aia\classification_assignment.role;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +'CLASS_SYSTEM' IN TYPEOF(aia\classification_assignment.assigned_class)) THEN
+  IF(role\classification_role.name <> 'class system membership') THEN
+    RETURN(FALSE);
+  END_IF;
+  REPEAT i:=LOINDEX(aia\applied_classification_assignment.items) TO HIINDEX(aia\applied_classification_assignment.items);
+    item:= aia\applied_classification_assignment.items[i];
+
+    IF (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CLASS_SYSTEM_ITEM'] * TYPEOF(item))=0) THEN
+-- item invalid if item does not belong to the types that may have a class_system
+	RETURN(FALSE);
+    END_IF;
+  END_REPEAT;
+END_IF;
+
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +'CHARACTERIZED_CLASS' IN TYPEOF(aia\classification_assignment.assigned_class)) THEN
+  IF	NOT(role\classification_role.name IN ['definitional','non-definitional','']) THEN
+    RETURN(FALSE); 
+  END_IF;
+
+
+  REPEAT i:=LOINDEX(aia\applied_classification_assignment.items) TO HIINDEX(aia\applied_classification_assignment.items);
+    item:= aia\applied_classification_assignment.items[i];
+
+    IF (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CLASSIFIED_ITEM'] * TYPEOF(item))=0) THEN
+-- item invalid if item does not belong to the types that may have a characterized_class
+	RETURN(FALSE);
+    END_IF;
+  END_REPEAT;
+END_IF;
+
+  IF
+   (role\classification_role.name = 'definitional')
+   THEN
+     IF NOT
+      (SIZEOF(QUERY(it <* aia\applied_classification_assignment.items | NOT
+             (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_FORMATION', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION'] * TYPEOF(it)) = 1)
+      )) = 0 )
+      THEN
+      RETURN(FALSE); 
+     END_IF;
+  END_IF;
+
+RETURN(TRUE);
+END_FUNCTION;
+
+FUNCTION closed_shell_reversed
+	(a_shell: closed_shell) : oriented_closed_shell;
+  LOCAL
+    the_reverse : oriented_closed_shell;
+  END_LOCAL;
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_CLOSED_SHELL' IN TYPEOF (a_shell) ) THEN
+      the_reverse := dummy_tri ||
+                    connected_face_set (
+                       a_shell\connected_face_set.cfs_faces) ||
+                    closed_shell () || oriented_closed_shell(
+                     a_shell\oriented_closed_shell.closed_shell_element,
+                       NOT(a_shell\oriented_closed_shell.orientation));
+   ELSE
+      the_reverse := dummy_tri ||
+               connected_face_set (
+                 a_shell\connected_face_set.cfs_faces) ||
+               closed_shell () || oriented_closed_shell (a_shell, FALSE);
+   END_IF;
+   RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION compute_total_depth
+	(swsrh: solid_with_stepped_round_hole) : positive_length_measure;
+LOCAL
+i  : positive_integer;
+n  : positive_integer := swsrh.segments;
+td : positive_length_measure := swsrh.segment_depths[1];
+END_LOCAL;
+
+IF n = 1 
+THEN RETURN(td);
+ELSE
+  REPEAT i := 2 TO n;
+    td := td + swsrh.segment_depths[i];
+  END_REPEAT;
+END_IF;
+RETURN(td);
+END_FUNCTION;
+
+FUNCTION conditional_reverse
+	(p: BOOLEAN; an_item: reversible_topology) : reversible_topology;
+IF p THEN
+     RETURN (an_item);
+   ELSE
+     RETURN (topology_reversed (an_item));
+   END_IF;
+END_FUNCTION;
+
+FUNCTION constraints_composite_curve_on_surface
+	(c: composite_curve_on_surface) : BOOLEAN;
+   LOCAL
+     n_segments : INTEGER := SIZEOF(c.segments);
+   END_LOCAL;
+        
+   REPEAT k := 1 TO n_segments;
+     IF (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN 
+           TYPEOF(c\composite_curve.segments[k].parent_curve))) AND
+        (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN 
+           TYPEOF(c\composite_curve.segments[k].parent_curve))) AND
+        (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE_ON_SURFACE' IN
+           TYPEOF(c\composite_curve.segments[k].parent_curve)))  THEN
+       RETURN (FALSE);
+     END_IF;
+   END_REPEAT;
+   RETURN(TRUE);
+END_FUNCTION;
+
+FUNCTION constraints_geometry_shell_based_surface_model
+	(m: shell_based_surface_model) : BOOLEAN;
+   LOCAL
+     result : BOOLEAN := TRUE;
+   END_LOCAL;
+   
+   REPEAT j := 1 TO SIZEOF(m.sbsm_boundary);
+     IF (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OPEN_SHELL' IN
+                     TYPEOF(m.sbsm_boundary[j])) AND
+        (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CLOSED_SHELL' IN
+           TYPEOF(m.sbsm_boundary[j]))))
+     THEN
+       result := FALSE;
+       RETURN(result);
+       (* A surface model is composed of OPEN_ and CLOSED_SHELLs. *)
+     END_IF;
+   END_REPEAT;
+   RETURN(result);
+END_FUNCTION;
+
+FUNCTION constraints_geometry_shell_based_wireframe_model
+	(m: shell_based_wireframe_model) : BOOLEAN;
+   LOCAL
+     result : BOOLEAN := TRUE;
+   END_LOCAL;
+
+   REPEAT j := 1 TO SIZEOF(m.sbwm_boundary);
+     IF (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN
+                    TYPEOF(m.sbwm_boundary[j])) AND
+        (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_SHELL' IN
+                      TYPEOF(m.sbwm_boundary[j]))))
+     THEN
+       result := FALSE;
+       RETURN(result);
+       (* A wireframe model is composed of WIRE_ and VERTEX_SHELLs *)
+     END_IF;
+   END_REPEAT;
+   RETURN(result);
+END_FUNCTION;
+
+FUNCTION constraints_param_b_spline
+	(degree: INTEGER; up_knots: INTEGER; up_cp: INTEGER; knot_mult: LIST [0:?] OF INTEGER; knots: LIST [0:?] OF parameter_value) : BOOLEAN;
+   LOCAL
+     result  : BOOLEAN := TRUE;
+     k, sum  : INTEGER;
+   END_LOCAL;
+   
+   (* Find sum of knot multiplicities. *)
+   sum := knot_mult[1];
+   
+   REPEAT i := 2 TO up_knots;
+     sum := sum + knot_mult[i];
+   END_REPEAT;
+   
+   (* Check limits holding for all B-spline parametrisations *)
+   IF (degree < 1) OR (up_knots < 2) OR (up_cp < degree) OR
+         (sum <> (degree + up_cp + 2)) THEN
+     result := FALSE;
+     RETURN(result);
+   END_IF;
+   
+   k := knot_mult[1];
+   
+   IF (k < 1) OR (k > degree + 1) THEN
+     result := FALSE;
+     RETURN(result);
+   END_IF;
+      
+   REPEAT i := 2 TO up_knots;
+     IF (knot_mult[i] < 1) OR (knots[i] <= knots[i-1]) THEN
+       result := FALSE;
+       RETURN(result);
+     END_IF;
+        
+     k := knot_mult[i];
+     
+     IF (i < up_knots) AND (k > degree) THEN
+       result := FALSE;
+       RETURN(result);
+     END_IF;
+        
+     IF (i = up_knots) AND (k > degree + 1) THEN
+       result := FALSE;
+       RETURN(result);
+     END_IF;
+   END_REPEAT;
+   RETURN(result);
+END_FUNCTION;
+
+FUNCTION constraints_rectangular_composite_surface
+	(s: rectangular_composite_surface) : BOOLEAN;
+REPEAT i := 1 TO s.n_u;
+       REPEAT j := 1 TO s.n_v;
+         IF NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_SURFACE' IN TYPEOF
+                    (s.segments[i][j].parent_surface)) OR
+                 ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RECTANGULAR_TRIMMED_SURFACE' IN TYPEOF
+                    (s.segments[i][j].parent_surface))) THEN
+           RETURN(FALSE);
+       END_IF;
+     END_REPEAT;
+   END_REPEAT;
+
+   (* Check the transition codes, omitting the last row or column *)
+   REPEAT i := 1 TO s.n_u-1;
+     REPEAT j := 1 TO s.n_v;
+       IF s.segments[i][j].u_transition = discontinuous THEN
+         RETURN(FALSE);
+       END_IF;
+     END_REPEAT;
+   END_REPEAT;
+   
+   REPEAT i := 1 TO s.n_u;
+     REPEAT j := 1 TO s.n_v-1;
+       IF s.segments[i][j].v_transition = discontinuous THEN
+         RETURN(FALSE);
+       END_IF;
+     END_REPEAT;
+   END_REPEAT;
+   RETURN(TRUE);
+END_FUNCTION;
+
+FUNCTION control_characters_free
+	(s: STRING) : BOOLEAN;
+    LOCAL
+      ch : STRING;
+    END_LOCAL;
+
+    REPEAT i:=1 TO LENGTH(s);
+      ch := s[i];
+      IF (ch = '\x9') OR (ch = '\xA') OR (ch = '\xD') THEN
+        RETURN(FALSE);
+      END_IF;
+    END_REPEAT;
+    RETURN (TRUE);
+END_FUNCTION;
+
+FUNCTION cross_product
+	(arg1: direction; arg2: direction) : vector;
+  LOCAL
+    mag    : REAL;
+    res    : direction;
+    v1,v2  : LIST[3:3] OF REAL;
+    result : vector;
+  END_LOCAL;
+  
+  IF ( NOT EXISTS (arg1) OR (arg1.dim = 2)) OR
+     ( NOT EXISTS (arg2) OR (arg2.dim = 2)) THEN
+    RETURN(?);
+  ELSE
+    BEGIN
+      v1  := normalise(arg1).direction_ratios;
+      v2  := normalise(arg2).direction_ratios;
+      res := dummy_gri || direction([(v1[2]*v2[3] - v1[3]*v2[2]),
+            (v1[3]*v2[1] - v1[1]*v2[3]), (v1[1]*v2[2] - v1[2]*v2[1])]);
+      mag := 0.0;
+      REPEAT i := 1 TO 3;
+        mag := mag + res.direction_ratios[i]*res.direction_ratios[i];
+      END_REPEAT;
+      IF (mag > 0.0) THEN
+        result := dummy_gri || vector(res, SQRT(mag));
+      ELSE
+        result := dummy_gri || vector(arg1, 0.0);
+      END_IF;
+      RETURN(result);
+    END;
+  END_IF;
+END_FUNCTION;
+
+FUNCTION curve_weights_positive
+	(b: rational_b_spline_curve) : BOOLEAN;
+   LOCAL
+     result : BOOLEAN := TRUE;
+   END_LOCAL;
+
+   REPEAT i := 0 TO b.upper_index_on_control_points;
+     IF b.weights[i] <= 0.0  THEN
+       result := FALSE;
+       RETURN(result);
+     END_IF;
+   END_REPEAT;
+   RETURN(result);
+END_FUNCTION;
+
+FUNCTION default_tolerance_table_cell_wr2
+	(agg: compound_item_definition) : BOOLEAN;
+BEGIN 
+IF SIZEOF(agg) <= 5 THEN 
+  RETURN(TRUE); 
+ELSE 
+  RETURN(FALSE); 
+END_IF; 
+END;
+END_FUNCTION;
+
+FUNCTION default_tolerance_table_cell_wr3
+	(agg: compound_item_definition) : BOOLEAN;
+BEGIN 
+IF (SIZEOF(QUERY ( i <* agg | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF(i)) 
+  AND (i\representation_item.name = 'significant number of digits')) )) = 1) OR 
+((SIZEOF(QUERY ( i <* agg | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF(i)) AND 
+  (i\representation_item.name = 'lower limit')) )) = 1) AND 
+(SIZEOF( QUERY ( i <* agg | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF(i)) AND 
+  (i\representation_item.name = 'upper limit')) )) = 1)) THEN 
+  RETURN(TRUE); 
+ELSE 
+  RETURN(FALSE); 
+END_IF; 
+END;
+END_FUNCTION;
+
+FUNCTION default_tolerance_table_cell_wr4
+	(agg: compound_item_definition) : BOOLEAN;
+BEGIN 
+IF (SIZEOF(QUERY ( i <* agg | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF(i)) AND 
+  (i\representation_item.name = 'plus minus tolerance value')) )) = 1) OR 
+((SIZEOF(QUERY ( i <* agg | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF(i)) AND (
+  i\representation_item.name = 'lower tolerance value')) )) = 1) AND 
+(SIZEOF( QUERY ( i <* agg | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF(i)) AND (
+  i\representation_item.name = 'upper tolerance value')) )) = 1)) THEN 
+  RETURN(TRUE); 
+ELSE 
+  RETURN(FALSE); 
+END_IF; 
+END;
+END_FUNCTION;
+
+FUNCTION default_tolerance_table_cell_wr5
+	(agg: compound_item_definition) : BOOLEAN;
+BEGIN 
+IF (SIZEOF(QUERY ( i <* agg | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF(i)) )) <= 1) AND 
+(SIZEOF(QUERY ( i <* agg | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF(i)) )) = 
+  SIZEOF(QUERY ( i <* agg | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF(i)) AND 
+  (i\representation_item.name = 'cell description'))) )) 
+THEN 
+  RETURN(TRUE); 
+ELSE 
+  RETURN(FALSE); 
+END_IF; 
+END;
+END_FUNCTION;
+
+FUNCTION dependently_instantiated
+	(set_of_input_instances: SET [0:?] OF GENERIC: igen; set_of_input_types: SET [0:?] OF STRING; previous_in_chain: LIST [0:?] OF GENERIC: cgen) : BOOLEAN;
+LOCAL
+  number_of_input_instances     : INTEGER;
+  number_of_referring_instances : INTEGER;
+  bag_of_referring_instances    : BAG OF GENERIC:igen := [];
+  dependently_instantiated_flag : BOOLEAN;
+  previous_in_chain_plus        : LIST OF GENERIC:cgen := [];
+  result                        : BOOLEAN := true;
+  set_of_types                  : SET OF STRING := [];
+END_LOCAL;
+
+IF EXISTS(set_of_input_instances) THEN
+  number_of_input_instances := SIZEOF(set_of_input_instances);
+  (* Add the declared type of bag_of_referring_instances to the set of
+     types of the REFERENCEd instances for the subset comparison later.
+   *)
+  set_of_input_types := set_of_input_types + 'GENERIC';
+  REPEAT i:=1 TO number_of_input_instances;
+    (* Determine all references to the current input instance. *)
+    bag_of_referring_instances := USEDIN (set_of_input_instances[i] , '');
+    IF EXISTS(bag_of_referring_instances) THEN
+      number_of_referring_instances := SIZEOF(bag_of_referring_instances);
+      dependently_instantiated_flag := false;
+      REPEAT j:=1 TO number_of_referring_instances;
+        (* Determine the type strings of the current referencing instance.
+         *)
+        set_of_types := TYPEOF(bag_of_referring_instances[j]);
+        (* If the referencing instance is of one of the types of the
+           only dependently instantiable select items, the current input
+           instance may still be invalidly instantiated.
+           Otherwise it is OK, and the next input instance is tested.
+         *)
+        IF set_of_types <= set_of_input_types THEN -- subset operator
+          (* The referring instance is of one of the restricted types.
+             However, it may itself be referred to by a valid instance;
+             then also the current instance would be valid.
+             Thus, call this function recursively with the referring
+             instance as input.
+             To avoid an infinite loop in case a set of instances
+             reference each other in a closed loop, test first whether
+             the current referencing instance is in the list of
+             previously processed chain members.
+           *)
+          IF NOT (bag_of_referring_instances[j] IN previous_in_chain) THEN
+            previous_in_chain_plus := previous_in_chain +
+            set_of_input_instances[i];
+            IF dependently_instantiated([bag_of_referring_instances[j]],
+              set_of_input_types,
+              previous_in_chain_plus) THEN
+              dependently_instantiated_flag := true;
+              ESCAPE; -- dependently instantiated; next input instance
+            ELSE
+              (* Not dependently instantiated: go to next referring
+              instance. *)
+              SKIP;
+            END_IF;
+          END_IF;
+        ELSE
+          dependently_instantiated_flag := true;
+          ESCAPE; -- dependently instantiated; take next input instance
+        END_IF;
+      END_REPEAT;
+      IF NOT dependently_instantiated_flag THEN
+        RETURN(false);
+      END_IF;
+    ELSE
+      RETURN(false); -- not referenced at all => invalidly instantiated
+    END_IF;
+  END_REPEAT;
+ELSE
+  RETURN(false); -- no input
+END_IF;
+
+RETURN(true);
+END_FUNCTION;
+
+FUNCTION derive_angle
+	(placement_1: axis2_placement_3d; placement_2: axis2_placement_3d) : plane_angle_measure;
+    LOCAL
+      v1     : direction;
+      v2     : direction;
+      mag_v1 : REAL;
+      mag_v2 : REAL;
+      theta  : plane_angle_measure;
+    END_LOCAL;
+    v1 := placement_1.p[1];
+    v2 := placement_2.p[1];
+    mag_v1 := SQRT (v1.direction_ratios[1]*v1.direction_ratios[1] +
+                    v1.direction_ratios[2]*v1.direction_ratios[2]);
+    mag_v2 := SQRT (v2.direction_ratios[1]*v2.direction_ratios[1] +
+                    v2.direction_ratios[2]*v2.direction_ratios[2]);
+    IF ((mag_v1 = 0.0) OR (mag_v2 = 0.0)) THEN
+      theta := 0.0;
+      RETURN (theta);
+    END_IF;
+    theta := ACOS ((v1.direction_ratios[1]*v2.direction_ratios[1] +
+                    v1.direction_ratios[2]*v2.direction_ratios[2]) /
+                   (mag_v1*mag_v2));
+    RETURN (theta);
+END_FUNCTION;
+
+FUNCTION derive_dimensional_exponents
+	(x: unit) : dimensional_exponents;
+    LOCAL
+      result : dimensional_exponents := dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+    END_LOCAL;
+
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DERIVED_UNIT' IN TYPEOF(x) THEN
+      REPEAT i := LOINDEX(x\derived_unit.elements) TO HIINDEX(x\derived_unit.elements);
+        result.length_exponent := result.length_exponent + 
+        (x\derived_unit.elements[i]\derived_unit_element.exponent * 
+         x\derived_unit.elements[i]\derived_unit_element.unit\named_unit.dimensions.length_exponent);
+        result.mass_exponent := result.mass_exponent + 
+        (x\derived_unit.elements[i]\derived_unit_element.exponent * 
+         x\derived_unit.elements[i]\derived_unit_element.unit\named_unit.dimensions.mass_exponent);
+        result.time_exponent := result.time_exponent + 
+        (x\derived_unit.elements[i]\derived_unit_element.exponent * 
+         x\derived_unit.elements[i]\derived_unit_element.unit\named_unit.dimensions.time_exponent);
+        result.electric_current_exponent := result.electric_current_exponent + 
+        (x\derived_unit.elements[i]\derived_unit_element.exponent * 
+         x\derived_unit.elements[i]\derived_unit_element.unit\named_unit.dimensions.electric_current_exponent);
+        result.thermodynamic_temperature_exponent := result.thermodynamic_temperature_exponent + 
+        (x\derived_unit.elements[i]\derived_unit_element.exponent * 
+         x\derived_unit.elements[i]\derived_unit_element.unit\named_unit.dimensions.thermodynamic_temperature_exponent);
+        result.amount_of_substance_exponent := result.amount_of_substance_exponent + 
+        (x\derived_unit.elements[i]\derived_unit_element.exponent * 
+         x\derived_unit.elements[i]\derived_unit_element.unit\named_unit.dimensions.amount_of_substance_exponent);
+        result.luminous_intensity_exponent := result.luminous_intensity_exponent + 
+        (x\derived_unit.elements[i]\derived_unit_element.exponent * 
+         x\derived_unit.elements[i]\derived_unit_element.unit\named_unit.dimensions.luminous_intensity_exponent);
+      END_REPEAT;
+    ELSE
+      result := x\named_unit.dimensions;
+    END_IF;
+    RETURN (result);
+END_FUNCTION;
+
+FUNCTION dimension_of
+	(item: geometric_representation_item) : dimension_count;
+  LOCAL
+    x   : SET OF representation;
+    y   : representation_context;
+    dim : dimension_count;
+  END_LOCAL;
+  -- For cartesian_point, direction, or vector dimension is determined by
+  -- counting components.
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF(item) THEN
+       dim := SIZEOF(item\cartesian_point.coordinates);
+       RETURN(dim);
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIRECTION' IN TYPEOF(item) THEN
+       dim := SIZEOF(item\direction.direction_ratios);
+       RETURN(dim);
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VECTOR' IN TYPEOF(item) THEN
+       dim := SIZEOF(item\vector.orientation\direction.direction_ratios);
+       RETURN(dim);
+    END_IF;
+  -- For all other types of geometric_representation_item dim is obtained
+  -- via context.
+  -- Find the set of representation in which the item is used. 
+
+  x := using_representations(item);
+
+  -- Determines the dimension_count of the 
+  -- geometric_representation_context. Note that the 
+  -- RULE compatible_dimension ensures that the context_of_items
+  -- is of type geometric_representation_context and has
+  -- the same dimension_count for all values of x.
+  -- The SET x is non-empty since this is required by WR1 of
+  -- representation_item.
+    y := x[1].context_of_items;
+    dim := y\geometric_representation_context.coordinate_space_dimension;
+    RETURN (dim);
+END_FUNCTION;
+
+FUNCTION dimensions_for_si_unit
+	(n: si_unit_name) : dimensional_exponents;
+CASE n OF 
+      metre:
+        RETURN (dimensional_exponents(1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
+      gram:
+        RETURN (dimensional_exponents(0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0));
+      second:
+        RETURN (dimensional_exponents(0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0));
+      ampere:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0));
+      kelvin:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0));
+      mole:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0));
+      candela:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0));
+      radian:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
+      steradian:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
+      hertz:
+        RETURN (dimensional_exponents(0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0));
+      newton:
+        RETURN (dimensional_exponents(1.0, 1.0, -2.0, 0.0, 0.0, 0.0, 0.0));
+      pascal:
+        RETURN (dimensional_exponents(-1.0, 1.0, -2.0, 0.0, 0.0, 0.0, 0.0));
+      joule:
+        RETURN (dimensional_exponents(2.0, 1.0, -2.0, 0.0, 0.0, 0.0, 0.0));
+      watt:
+        RETURN (dimensional_exponents(2.0, 1.0, -3.0, 0.0, 0.0, 0.0, 0.0));
+      coulomb:
+        RETURN (dimensional_exponents(0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0));
+      volt:
+        RETURN (dimensional_exponents(2.0, 1.0, -3.0, -1.0, 0.0, 0.0, 0.0));
+      farad:
+        RETURN (dimensional_exponents(-2.0, -1.0, 4.0, 1.0, 0.0, 0.0, 0.0));
+      ohm:
+        RETURN (dimensional_exponents(2.0, 1.0, -3.0, -2.0, 0.0, 0.0, 0.0));
+      siemens:
+        RETURN (dimensional_exponents(-2.0, -1.0, 3.0, 2.0, 0.0, 0.0, 0.0));
+      weber:
+        RETURN (dimensional_exponents(2.0, 1.0, -2.0, -1.0, 0.0, 0.0, 0.0));
+      tesla:
+        RETURN (dimensional_exponents(0.0, 1.0, -2.0, -1.0, 0.0, 0.0, 0.0));
+      henry:
+        RETURN (dimensional_exponents(2.0, 1.0, -2.0, -2.0, 0.0, 0.0, 0.0));
+      degree_Celsius:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0));
+      lumen:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0));
+      lux:
+        RETURN (dimensional_exponents(-2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0));
+      becquerel:
+        RETURN (dimensional_exponents(0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0));
+      gray:
+        RETURN (dimensional_exponents(2.0, 0.0, -2.0, 0.0, 0.0, 0.0, 0.0));
+      sievert:
+        RETURN (dimensional_exponents(2.0, 0.0, -2.0, 0.0, 0.0, 0.0, 0.0));
+      OTHERWISE:
+        RETURN (?);
+    END_CASE;
+END_FUNCTION;
+
+FUNCTION dot_product
+	(arg1: direction; arg2: direction) : REAL;
+   LOCAL
+     scalar : REAL;
+     vec1, vec2: direction;
+     ndim : INTEGER;
+   END_LOCAL;
+   
+   IF NOT EXISTS (arg1) OR NOT EXISTS (arg2) THEN
+     scalar := ?;
+     (* When function is called with invalid data an indeterminate result
+     is returned *)
+   ELSE
+     IF (arg1.dim <> arg2.dim) THEN
+       scalar := ?;
+     (* When function is called with invalid data an indeterminate result
+     is returned *)
+     ELSE
+       BEGIN
+         vec1   := normalise(arg1);
+         vec2   := normalise(arg2);
+         ndim   := arg1.dim;
+         scalar := 0.0;
+         REPEAT  i := 1 TO ndim;
+           scalar := scalar +
+                       vec1.direction_ratios[i]*vec2.direction_ratios[i];
+         END_REPEAT;
+       END;
+     END_IF;
+   END_IF;
+   RETURN (scalar);
+END_FUNCTION;
+
+FUNCTION edge_reversed
+	(an_edge: edge) : oriented_edge;
+   LOCAL
+     the_reverse : oriented_edge;
+   END_LOCAL;
+
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_EDGE' IN TYPEOF (an_edge) ) THEN
+     the_reverse  := dummy_tri ||
+             edge(an_edge.edge_end, an_edge.edge_start) ||
+             oriented_edge(an_edge\oriented_edge.edge_element,
+                        NOT (an_edge\oriented_edge.orientation)) ;
+   ELSE
+     the_reverse := dummy_tri ||
+             edge(an_edge.edge_end, an_edge.edge_start) ||
+             oriented_edge(an_edge, FALSE);
+   END_IF;
+   RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION external_version_assignment_is_valid
+	(aia: applied_external_identification_assignment) : BOOLEAN;
+    LOCAL
+      item: identification_item;
+      role: identification_role;
+    END_LOCAL;
+      role:= aia.role;
+      IF role.name='version' THEN
+        REPEAT i:=LOINDEX(aia.items) TO HIINDEX(aia.items);
+          item:= aia.items[i];
+          IF (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'EXTERNALLY_VERSIONED_ITEM']*TYPEOF(item))=0) THEN
+            -- item invalid if item does not belong to versionable types
+	        RETURN(FALSE);
+          END_IF;
+        END_REPEAT;
+        RETURN(TRUE);
+      ELSE		-- case where aia does not convey a version id
+        RETURN(TRUE);
+      END_IF;
+END_FUNCTION;
+
+FUNCTION face_bound_reversed
+	(a_face_bound: face_bound) : face_bound;
+   LOCAL
+     the_reverse : face_bound ;
+   END_LOCAL;
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_OUTER_BOUND' IN TYPEOF (a_face_bound) ) THEN
+     the_reverse := dummy_tri ||
+                      face_bound(a_face_bound\face_bound.bound,
+                           NOT (a_face_bound\face_bound.orientation))
+                            || face_outer_bound() ;
+   ELSE
+     the_reverse := dummy_tri ||
+         face_bound(a_face_bound.bound, NOT(a_face_bound.orientation));
+   END_IF;
+  RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION face_reversed
+	(a_face: face) : oriented_face;
+   LOCAL
+     the_reverse : oriented_face ;
+   END_LOCAL;
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_FACE' IN TYPEOF (a_face) ) THEN
+     the_reverse := dummy_tri ||
+       face(set_of_topology_reversed(a_face.bounds)) ||
+          oriented_face(a_face\oriented_face.face_element,
+                           NOT (a_face\oriented_face.orientation)) ;
+   ELSE
+     the_reverse := dummy_tri ||
+       face(set_of_topology_reversed(a_face.bounds)) ||
+                               oriented_face(a_face, FALSE) ;
+   END_IF;
+      RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION first_proj_axis
+	(z_axis: direction; arg: direction) : direction;
+  LOCAL
+    x_axis : direction;
+    v      : direction;
+    z      : direction;
+    x_vec  : vector;
+  END_LOCAL;
+  
+  IF (NOT EXISTS(z_axis)) THEN
+    RETURN (?) ;
+  ELSE
+    z := normalise(z_axis);
+    IF NOT EXISTS(arg) THEN
+      IF ((z.direction_ratios <> [1.0,0.0,0.0]) AND
+          (z.direction_ratios <> [-1.0,0.0,0.0]))  THEN
+        v :=  dummy_gri || direction([1.0,0.0,0.0]);
+      ELSE
+        v := dummy_gri || direction([0.0,1.0,0.0]);
+      END_IF;
+    ELSE
+      IF  (arg.dim <> 3) THEN
+        RETURN (?) ;
+      END_IF;
+      IF ((cross_product(arg,z).magnitude) = 0.0) THEN
+        RETURN (?);
+      ELSE
+        v := normalise(arg);
+      END_IF;
+    END_IF;
+    x_vec := scalar_times_vector(dot_product(v, z), z);
+    x_axis := vector_difference(v, x_vec).orientation;
+    x_axis := normalise(x_axis);
+  END_IF;
+  RETURN(x_axis);
+END_FUNCTION;
+
+FUNCTION gbsf_check_curve
+	(cv: representation_item) : BOOLEAN;
+IF SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_CURVE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D'] * TYPEOF(cv)) > 1 THEN
+    RETURN (FALSE);
+  END_IF;
+  IF SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCLE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELLIPSE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TRIMMED_CURVE'] * TYPEOF(cv)) = 1 THEN
+    RETURN (TRUE);
+  ELSE
+    IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' IN TYPEOF(cv)) AND (cv\b_spline_curve.self_intersect = FALSE) OR (cv\b_spline_curve.self_intersect = UNKNOWN)) THEN
+      RETURN (TRUE);
+    ELSE
+      IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE' IN TYPEOF(cv)) AND (cv\composite_curve.self_intersect = FALSE) OR (cv\composite_curve.self_intersect = UNKNOWN)) THEN
+        RETURN (SIZEOF(QUERY(seg <* cv\composite_curve.segments | NOT (gbsf_check_curve(seg.parent_curve)))) = 0);
+      ELSE
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA' IN TYPEOF(cv) THEN
+          RETURN (gbsf_check_curve(cv\curve_replica.parent_curve));
+        ELSE
+          IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D' IN TYPEOF(cv)) AND ((cv\offset_curve_3d.self_intersect = FALSE) OR (cv\offset_curve_3d.self_intersect = UNKNOWN)) AND (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF(cv\offset_curve_3d.basis_curve)))) THEN
+            RETURN (gbsf_check_curve(cv\offset_curve_3d.basis_curve));
+          ELSE
+            IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(cv) THEN
+              RETURN ((gbsf_check_curve(cv\pcurve.reference_to_curve\representation.items[1])) AND (gbsf_check_surface(cv\pcurve.basis_surface)));
+            ELSE
+              IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF(cv) THEN
+                IF (SIZEOF(cv\polyline.points) >= 3) THEN
+                  RETURN (TRUE);
+                END_IF;
+              ELSE
+                IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN TYPEOF(cv) THEN
+                  IF gbsf_check_curve(cv\surface_curve.curve_3d) THEN
+                    REPEAT i := 1 TO SIZEOF(cv\surface_curve.associated_geometry);
+                      IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE' IN TYPEOF(cv\surface_curve.associated_geometry[i]) THEN
+                        IF NOT gbsf_check_surface(cv\surface_curve.associated_geometry[i]) THEN
+                          RETURN (FALSE);
+                        END_IF;
+                      ELSE
+                        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(cv\surface_curve.associated_geometry[i]) THEN
+                          IF NOT gbsf_check_curve(cv\surface_curve.associated_geometry[i]) THEN
+                            RETURN (FALSE);
+                          END_IF;
+                        END_IF;
+                      END_IF;
+                    END_REPEAT;
+                    RETURN (TRUE);
+                  END_IF;
+                END_IF;
+              END_IF;
+            END_IF;
+          END_IF;
+        END_IF;
+      END_IF;
+    END_IF;
+  END_IF;
+  RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION gbsf_check_point
+	(pnt: point) : BOOLEAN;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF(pnt) THEN
+    RETURN (TRUE);
+  ELSE
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE' IN TYPEOF(pnt) THEN
+      RETURN (gbsf_check_curve(pnt\point_on_curve.basis_curve));
+    ELSE
+      IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_SURFACE' IN TYPEOF(pnt) THEN
+        RETURN (gbsf_check_surface(pnt\point_on_surface.basis_surface));
+      ELSE
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEGENERATE_PCURVE' IN TYPEOF(pnt) THEN
+          RETURN ((gbsf_check_curve(pnt\degenerate_pcurve.reference_to_curve\representation.items[1])) AND (gbsf_check_surface(pnt\degenerate_pcurve.basis_surface)));
+        END_IF;
+      END_IF;
+    END_IF;
+  END_IF;
+  RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION gbsf_check_surface
+	(sf: surface) : BOOLEAN;
+IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_SURFACE' IN TYPEOF(sf)) AND (sf\b_spline_surface.self_intersect = FALSE) OR (sf\b_spline_surface.self_intersect = UNKNOWN)) THEN
+    RETURN (TRUE);
+  ELSE
+    IF SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SPHERICAL_SURFACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TOROIDAL_SURFACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_BOUNDED_SURFACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RECTANGULAR_TRIMMED_SURFACE'] * TYPEOF(sf)) = 1 THEN
+      RETURN (TRUE);
+    ELSE
+      IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_SURFACE' IN TYPEOF(sf)) AND (sf\offset_surface.self_intersect = FALSE) OR (sf\offset_surface.self_intersect = UNKNOWN)) THEN
+        RETURN (gbsf_check_surface(sf\offset_surface.basis_surface));
+      ELSE
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RECTANGULAR_COMPOSITE_SURFACE' IN TYPEOF(sf) THEN
+          REPEAT i := 1 TO SIZEOF(sf\rectangular_composite_surface.segments);
+            REPEAT j := 1 TO SIZEOF(sf\rectangular_composite_surface.segments[i]);
+              IF NOT (gbsf_check_surface(sf\rectangular_composite_surface.segments[i][j].parent_surface)) THEN
+                RETURN (FALSE);
+              END_IF;
+            END_REPEAT;
+          END_REPEAT;
+          RETURN (TRUE);
+        ELSE
+          IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_REPLICA' IN TYPEOF(sf) THEN
+            RETURN (gbsf_check_surface(sf\surface_replica.parent_surface));
+          ELSE
+            IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_OF_REVOLUTION' IN TYPEOF(sf) THEN
+              RETURN (gbsf_check_curve(sf\swept_surface.swept_curve));
+            END_IF;
+          END_IF;
+        END_IF;
+      END_IF;
+    END_IF;
+  END_IF;
+  RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION get_basis_surface
+	(c: curve_on_surface) : SET [0:2] OF surface;
+  LOCAL
+    surfs  : SET[0:2] OF surface;
+    n      : INTEGER;
+  END_LOCAL;
+  surfs := [];
+  IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF (c) THEN
+    surfs := [c\pcurve.basis_surface];
+  ELSE
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN TYPEOF (c) THEN
+      n := SIZEOF(c\surface_curve.associated_geometry);
+      REPEAT i := 1 TO n;
+      surfs := surfs +
+                associated_surface(c\surface_curve.associated_geometry[i]);
+      END_REPEAT;
+    END_IF;
+  END_IF;
+  IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE_ON_SURFACE' IN TYPEOF (c) THEN
+   (* For a composite_curve_on_surface the basis_surface is the intersection
+    of the basis_surfaces of all the segments. *)
+     n := SIZEOF(c\composite_curve.segments);
+     surfs := get_basis_surface(
+                     c\composite_curve.segments[1].parent_curve);
+     IF n > 1 THEN
+       REPEAT i := 2 TO n;
+         surfs := surfs * get_basis_surface(
+                  c\composite_curve.segments[i].parent_curve);
+       END_REPEAT;
+     END_IF;
+
+  END_IF;
+  RETURN(surfs);
+END_FUNCTION;
+
+FUNCTION get_description_value
+	(obj: description_attribute_select) : text;
+    LOCAL
+      description_bag : BAG OF description_attribute := (USEDIN(obj, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.' + 'DESCRIBED_ITEM'));
+    END_LOCAL;
+
+    IF SIZEOF(description_bag) = 1 THEN
+      RETURN (description_bag[1].attribute_value);
+    ELSE
+      RETURN (?);
+    END_IF;
+END_FUNCTION;
+
+FUNCTION get_id_value
+	(obj: id_attribute_select) : identifier;
+    LOCAL
+      id_bag : BAG OF id_attribute := (USEDIN(obj, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.' + 'IDENTIFIED_ITEM'));
+    END_LOCAL;
+
+    IF SIZEOF(id_bag) = 1 THEN
+      RETURN (id_bag[1].attribute_value);
+    ELSE
+      RETURN (?);
+    END_IF;
+END_FUNCTION;
+
+FUNCTION get_name_value
+	(obj: name_attribute_select) : label;
+    LOCAL
+      name_bag : BAG OF name_attribute := (USEDIN(obj, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.' + 'NAMED_ITEM'));
+    END_LOCAL;
+
+    IF SIZEOF(name_bag) = 1 THEN
+      RETURN (name_bag[1].attribute_value);
+    ELSE
+      RETURN (?);
+    END_IF;
+END_FUNCTION;
+
+FUNCTION get_role
+	(obj: role_select) : object_role;
+    LOCAL
+      role_bag : BAG OF role_association := (USEDIN(obj, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.' + 'ITEM_WITH_ROLE'));
+    END_LOCAL;
+
+    IF SIZEOF(role_bag) = 1 THEN
+      RETURN (role_bag[1].role);
+    ELSE
+      RETURN (?);
+    END_IF;
+END_FUNCTION;
+
+FUNCTION get_shape_aspect_property_definition_representations
+	(s_a_instance: shape_aspect) : SET [0:?] OF property_definition_representation;
+LOCAL
+pd_set : SET OF property_definition := [];
+pdr_set : SET OF property_definition_representation := [] ;
+END_LOCAL;
+pd_set := bag_to_set(USEDIN(s_a_instance, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROPERTY_DEFINITION.DEFINITION'));
+IF (SIZEOF(pd_set) < 1) THEN
+RETURN (pdr_set);
+END_IF;
+REPEAT i := 1 TO HIINDEX(pd_set);
+pdr_set := pdr_set + (QUERY(pdr <* USEDIN(pd_set[i], 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PROPERTY_DEFINITION_REPRESENTATION.' + 'DEFINITION') |
+'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_DEFINITION_REPRESENTATION' IN TYPEOF(pdr)));
+END_REPEAT;
+RETURN (pdr_set);
+END_FUNCTION;
+
+FUNCTION is_acyclic
+	(arg: generic_expression) : BOOLEAN;
+RETURN (acyclic (arg, []));
+END_FUNCTION;
+
+FUNCTION is_int_expr
+	(arg: numeric_expression) : LOGICAL;
+LOCAL
+	i: INTEGER := 0;
+END_LOCAL;
+
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INT_LITERAL' IN TYPEOF(arg) 
+THEN 
+	RETURN (TRUE); 
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REAL_LITERAL' IN TYPEOF(arg) 
+THEN 
+	RETURN (FALSE); 
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INT_NUMERIC_VARIABLE' IN TYPEOF(arg) 
+THEN 
+	RETURN (TRUE); 
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REAL_NUMERIC_VARIABLE' IN TYPEOF(arg) 
+THEN 
+	RETURN (FALSE); 
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ABS_FUNCTION' IN TYPEOF(arg) 
+THEN 
+	RETURN (is_int_expr(arg\unary_numeric_expression.operand));
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MINUS_FUNCTION' IN TYPEOF(arg) 
+THEN 
+	RETURN (is_int_expr(arg\unary_numeric_expression.operand)); 
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SIN_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COS_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TAN_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ASIN_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ACOS_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ATAN_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EXP_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LOG_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LOG2_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LOG10_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SQUARE_ROOT_FUNCTION' 
+								IN TYPEOF(arg))
+THEN 
+	RETURN (FALSE);
+END_IF;
+IF 	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLUS_EXPRESSION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MULT_EXPRESSION' 
+								IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAXIMUM_FUNCTION'
+								IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MINIMUM_FUNCTION'
+								IN TYPEOF(arg)) 
+THEN 
+	REPEAT i :=1 TO SIZEOF (
+			arg\multiple_arity_numeric_expression.operands);
+	IF NOT 
+		is_int_expr(arg\multiple_arity_numeric_expression.operands[i]) 
+	THEN 
+		RETURN (FALSE);
+	END_IF;
+	END_REPEAT;
+	RETURN (TRUE);
+END_IF;
+IF 	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MINUS_EXPRESSION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POWER_EXPRESSION' 
+								IN TYPEOF(arg))
+THEN 
+	RETURN (is_int_expr(arg\binary_numeric_expression.operands[1])
+		AND is_int_expr(arg\binary_numeric_expression.operands[2]));
+END_IF;
+IF	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIV_EXPRESSION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MOD_EXPRESSION' IN TYPEOF(arg))
+THEN 
+	RETURN(TRUE);	
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SLASH_EXPRESSION' IN TYPEOF(arg) 
+THEN 
+	RETURN (FALSE); 	
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_FUNCTION' IN TYPEOF(arg) 
+THEN 
+	RETURN (TRUE); 
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VALUE_FUNCTION' IN TYPEOF(arg) 
+THEN 
+	IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INT_VALUE_FUNCTION' 
+								IN TYPEOF(arg) 
+	THEN 
+		RETURN (TRUE); 
+	ELSE 
+		RETURN (FALSE); 
+	END_IF;
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INTEGER_DEFINED_FUNCTION' 
+								IN TYPEOF(arg)
+THEN 
+	RETURN(TRUE) ;
+END_IF;
+IF'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REAL_DEFINED_FUNCTION' IN TYPEOF(arg) 
+THEN 
+	RETURN(FALSE) ;
+END_IF ;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOOLEAN_DEFINED_FUNCTION' 
+								IN TYPEOF(arg)
+THEN 
+	RETURN(FALSE) ;
+END_IF ;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_DEFINED_FUNCTION' 
+								IN TYPEOF(arg)
+THEN 
+	RETURN (FALSE) ;
+END_IF ;
+
+RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION is_SQL_mappable
+	(arg: expression) : LOGICAL;
+LOCAL
+	i: INTEGER;
+END_LOCAL;
+
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SIMPLE_NUMERIC_EXPRESSION' 
+								IN TYPEOF (arg) 
+THEN 
+	RETURN (TRUE);
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SQL_MAPPABLE_DEFINED_FUNCTION' 
+								IN TYPEOF (arg) 
+THEN 
+	RETURN (TRUE);
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MINUS_FUNCTION' IN TYPEOF(arg) 
+THEN 
+	RETURN (is_SQL_mappable(arg\unary_numeric_expression.operand)); 
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ABS_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SIN_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COS_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TAN_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ASIN_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ACOS_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ATAN_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EXP_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LOG_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LOG2_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LOG10_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SQUARE_ROOT_FUNCTION' 
+								IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VALUE_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_FUNCTION' 
+								IN TYPEOF(arg))
+THEN 
+	RETURN (FALSE);
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLUS_EXPRESSION' IN TYPEOF(arg)) 
+		OR('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MULT_EXPRESSION' IN TYPEOF(arg)) 
+		OR('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAXIMUM_FUNCTION' 
+								IN TYPEOF(arg)) 
+		OR('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MINIMUM_FUNCTION' 
+								IN TYPEOF(arg)) 
+THEN 
+	REPEAT i :=1 TO SIZEOF (
+			arg\multiple_arity_numeric_expression.operands);
+		IF NOT is_SQL_mappable(
+			arg\multiple_arity_numeric_expression.operands[i])
+		THEN 
+			RETURN (FALSE);
+		END_IF;
+	END_REPEAT;
+RETURN (TRUE);
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MINUS_EXPRESSION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SLASH_EXPRESSION' IN 
+								TYPEOF(arg))
+THEN
+		RETURN (is_SQL_mappable(
+			arg\binary_numeric_expression.operands[1])
+		AND is_SQL_mappable(arg\binary_numeric_expression.operands[2]));
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIV_EXPRESSION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MOD_EXPRESSION' IN TYPEOF(arg)) 
+		OR('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POWER_EXPRESSION' 
+								IN TYPEOF(arg))
+THEN 
+	RETURN (FALSE); 	
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SIMPLE_BOOLEAN_EXPRESSION' 
+								IN TYPEOF (arg) 
+THEN 
+	RETURN (TRUE);
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NOT_EXPRESSION' IN TYPEOF (arg) 
+THEN 
+	RETURN (is_SQL_mappable (arg\UNARY_GENERIC_EXPRESSION.OPERAND));
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ODD_FUNCTION'IN TYPEOF (arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.XOR_EXPRESSION' 
+								IN TYPEOF (arg)) 
+THEN	
+	RETURN (FALSE);
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AND_EXPRESSION' IN TYPEOF (arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OR_EXPRESSION' IN TYPEOF (arg)) 
+THEN
+	REPEAT i:=1 TO SIZEOF (
+			arg\MULTIPLE_ARITY_BOOLEAN_EXPRESSION.OPERANDS);
+		IF NOT is_SQL_mappable (
+			arg\MULTIPLE_ARITY_BOOLEAN_EXPRESSION.OPERANDS[i]) 
+		THEN 
+			RETURN (FALSE);
+		END_IF;
+	END_REPEAT;
+	RETURN (TRUE);
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EQUALS_EXPRESSION' IN TYPEOF (arg) 
+THEN
+	RETURN(is_SQL_mappable (
+			arg\BINARY_GENERIC_EXPRESSION.OPERANDS [1])
+		AND is_SQL_mappable(
+			arg\BINARY_GENERIC_EXPRESSION.OPERANDS [2]));
+END_IF;
+IF	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPARISON_EQUAL' IN TYPEOF (arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPARISON_GREATER' 
+								IN TYPEOF (arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPARISON_GREATER_EQUAL'
+								IN TYPEOF (arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPARISON_LESS' 
+								IN TYPEOF (arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPARISON_LESS_EQUAL' 
+								IN TYPEOF (arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPARISON_NOT_EQUAL' 
+								IN TYPEOF (arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LIKE_EXPRESSION' 
+								IN TYPEOF (arg)) 
+THEN
+	RETURN (is_SQL_mappable (arg\COMPARISON_EXPRESSION.OPERANDS[1])
+		AND is_SQL_mappable (arg\COMPARISON_EXPRESSION.OPERANDS[2]));
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INTERVAL_EXPRESSION' IN TYPEOF(arg) 
+THEN 
+	RETURN (is_SQL_mappable(arg\interval_expression.interval_low) 
+		AND is_SQL_mappable(arg\interval_expression.interval_high)
+		AND is_SQL_mappable(arg\interval_expression.interval_item));
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NUMERIC_DEFINED_FUNCTION' 
+								IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOOLEAN_DEFINED_FUNCTION' 
+								IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_DEFINED_FUNCTION' 
+								IN TYPEOF(arg))  
+THEN 
+		RETURN (FALSE) ;
+END_IF;
+
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SIMPLE_STRING_EXPRESSION' 
+								IN TYPEOF(ARG) 
+THEN 
+	RETURN (TRUE);
+END_IF;
+IF 	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INDEX_EXPRESSION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBSTRING_EXPRESSION' 
+								IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONCAT_EXPRESSION' 
+								IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FORMAT_FUNCTION' 
+								IN TYPEOF(arg)) 
+THEN 
+	RETURN (FALSE);
+END_IF;
+
+	RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION item_in_context
+	(item: representation_item; cntxt: representation_context) : BOOLEAN;
+    LOCAL
+      y : BAG OF representation_item;
+    END_LOCAL;
+    -- If there is one or more representation using both the item
+    -- and cntxt return true.
+    IF SIZEOF(USEDIN(item,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION.ITEMS')
+      * cntxt.representations_in_context) > 0 THEN
+      RETURN (TRUE);
+      -- Determine the bag of representation_items that reference
+      -- item
+      ELSE y := QUERY(z <* USEDIN (item , '') |
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION_ITEM' IN TYPEOF(z));
+        -- Ensure that the bag is not empty
+        IF SIZEOF(y) > 0 THEN
+        -- For each element in the bag
+        REPEAT i := 1 TO HIINDEX(y);
+          -- Check to see it is an item in the input cntxt.
+          IF item_in_context(y[i], cntxt) THEN
+            RETURN (TRUE);
+          END_IF;
+        END_REPEAT;
+      END_IF;
+    END_IF;
+    -- Return false when all possible branches have been checked
+    -- with no success.
+    RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION leap_year
+	(year: year_number) : BOOLEAN;
+IF ((((year MOD 4) = 0) AND ((year MOD 100) <> 0)) OR ((year MOD 400) = 0)) THEN
+    RETURN (TRUE);
+  ELSE
+    RETURN (FALSE);
+  END_IF;
+END_FUNCTION;
+
+FUNCTION list_face_loops
+	(f: face) : LIST [0:?] OF loop;
+   LOCAL
+     loops : LIST[0:?] OF loop := [];
+   END_LOCAL;
+   
+   REPEAT i := 1 TO SIZEOF(f.bounds);
+     loops := loops +(f.bounds[i].bound);
+   END_REPEAT;
+      
+   RETURN(loops);
+END_FUNCTION;
+
+FUNCTION list_of_topology_reversed
+	(a_list: list_of_reversible_topology_item) : list_of_reversible_topology_item;
+   LOCAL
+     the_reverse : list_of_reversible_topology_item;
+   END_LOCAL;
+    
+   the_reverse := [];
+   REPEAT i := 1 TO SIZEOF (a_list);
+     the_reverse := topology_reversed (a_list [i]) + the_reverse;
+   END_REPEAT;
+  
+   RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION list_to_array
+	(lis: LIST [0:?] OF GENERIC: T; low: INTEGER; u: INTEGER) : ARRAY [low:u] OF GENERIC: T;
+   LOCAL
+     n   : INTEGER;
+     res : ARRAY [low:u] OF GENERIC : T;
+   END_LOCAL;
+      
+   n := SIZEOF(lis);
+   IF (n <> (u-low +1)) THEN
+     RETURN(?);
+   ELSE
+     res := [lis[1] : n];
+     REPEAT i := 2 TO n;
+       res[low+i-1] := lis[i];
+     END_REPEAT;
+     RETURN(res);
+   END_IF;
+END_FUNCTION;
+
+FUNCTION list_to_set
+	(l: LIST [0:?] OF GENERIC: T) : SET [0:?] OF GENERIC: T;
+   LOCAL
+     s : SET OF GENERIC:T := [];
+   END_LOCAL;
+      
+   REPEAT i := 1 TO SIZEOF(l);
+     s := s + l[i];
+   END_REPEAT;
+   
+   RETURN(s);
+END_FUNCTION;
+
+FUNCTION make_array_of_array
+	(lis: LIST [1:?] OF LIST [1:?] OF GENERIC: T; low1: INTEGER; u1: INTEGER; low2: INTEGER; u2: INTEGER) : ARRAY [low1:u1] OF ARRAY [low2:u2] OF GENERIC: T;
+   LOCAL
+     res   : ARRAY[low1:u1] OF ARRAY [low2:u2] OF GENERIC : T;
+   END_LOCAL;
+
+(* Check input dimensions for consistency *)
+   IF (u1-low1+1) <> SIZEOF(lis) THEN
+     RETURN (?);
+   END_IF;
+   IF (u2 - low2 + 1 ) <> SIZEOF(lis[1]) THEN
+     RETURN (?) ;
+   END_IF;
+(* Initialise res with values from lis[1] *)
+   res := [list_to_array(lis[1], low2, u2) : (u1-low1 + 1)];
+   REPEAT i := 2 TO HIINDEX(lis);
+     IF (u2-low2+1) <> SIZEOF(lis[i]) THEN
+       RETURN (?);
+     END_IF;     
+     res[low1+i-1] := list_to_array(lis[i], low2, u2);
+   END_REPEAT; 
+   
+   RETURN (res);
+END_FUNCTION;
+
+FUNCTION mixed_loop_type_set
+	(l: SET [0:?] OF loop) : LOGICAL;
+    LOCAL
+      poly_loop_type: LOGICAL;
+    END_LOCAL;
+    IF(SIZEOF(l) <= 1) THEN
+      RETURN(FALSE);
+    END_IF;
+    poly_loop_type := ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLY_LOOP' IN TYPEOF(l[1]));
+    REPEAT i := 2 TO SIZEOF(l);
+      IF(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLY_LOOP' IN TYPEOF(l[i])) <> poly_loop_type)
+          THEN
+          RETURN(TRUE);
+       END_IF;
+    END_REPEAT;
+    RETURN(FALSE);
+END_FUNCTION;
+
+FUNCTION msb_shells
+	(brep: manifold_solid_brep) : SET [1:?] OF closed_shell;
+    LOCAL   
+      return_set: SET[1:?] OF closed_shell := [brep.outer];   
+    END_LOCAL;   
+
+    IF SIZEOF(QUERY(msbtype <* TYPEOF(brep) |   
+                 msbtype LIKE '*BREP_WITH_VOIDS'))  >= 1    
+          THEN   
+       return_set := return_set + brep\brep_with_voids.voids;   
+    END_IF;   
+   RETURN(return_set);
+END_FUNCTION;
+
+FUNCTION msf_curve_check
+	(cv: representation_item) : BOOLEAN;
+IF SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_CURVE',
+  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC',
+  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE',
+  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D'] * TYPEOF(cv)) > 1 THEN
+  RETURN(FALSE);
+END_IF;
+
+(* b_spline_curves shall not self-intersect
+ *)
+IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' IN TYPEOF (cv)) AND
+  (cv\b_spline_curve.self_intersect = FALSE)OR
+  (cv\b_spline_curve.self_intersect = UNKNOWN)) THEN
+  RETURN(TRUE);
+ELSE
+
+  (* conics and lines are valid curve types
+   *)
+  IF SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE'] 
+    * TYPEOF (cv)) = 1 THEN
+    RETURN(TRUE);
+  ELSE
+
+    (* a curve_replica shall reference a valid curve
+     *)
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA' IN TYPEOF(cv) THEN
+      RETURN (msf_curve_check(cv\curve_replica.parent_curve)); 
+    ELSE 
+ 
+      (* an offset_curve_3d shall not self-intersect and
+         shall reference a valid curve; a polyline is not a
+         valid basis_curve
+       *)
+      IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D' IN TYPEOF (cv))
+        AND
+        ((cv\offset_curve_3d.self_intersect = FALSE) OR
+        (cv\offset_curve_3d.self_intersect = UNKNOWN))
+        AND
+        (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF
+        (cv\offset_curve_3d.basis_curve)))) THEN
+        RETURN (msf_curve_check(cv\offset_curve_3d.basis_curve)); 
+      ELSE 
+ 
+        (* a pcurve shall reference a valid curve and a valid
+           basis_surface
+         *)
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(cv) THEN 
+          RETURN ((msf_curve_check
+          (cv\pcurve.reference_to_curve\representation.items[1])) AND
+          (msf_surface_check(cv\pcurve.basis_surface)));
+        ELSE 
+ 
+          (* a surface_curve references a curve_3d and one or
+             two pcurves or one or two surfaces or one of
+             each; all of these references shall be valid
+           *)
+          IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN TYPEOF(cv) THEN 
+
+            (* if the curve reference is correct, check also the rest
+             *)
+            IF msf_curve_check(cv\surface_curve.curve_3d) THEN
+              REPEAT i := 1 TO SIZEOF
+              (cv\surface_curve.associated_geometry);
+
+                (* do for one or two associated_geometrys:
+                 *)
+                IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE' IN 
+                  TYPEOF (cv\surface_curve.associated_geometry[i]) THEN  
+                  IF NOT msf_surface_check
+                    (cv\surface_curve.associated_geometry[i]) THEN  
+                    RETURN(FALSE);  
+                  END_IF;  
+                ELSE  
+                  IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF 
+                    (cv\surface_curve.associated_geometry[i]) THEN  
+                    IF NOT msf_curve_check
+                      (cv\surface_curve.associated_geometry[i]) THEN 
+                      RETURN(FALSE);  
+                    END_IF;  
+                  END_IF;  
+                END_IF; 
+              END_REPEAT;  
+              RETURN(TRUE);
+            END_IF; 
+          ELSE
+
+            (* a polyline shall have at least 3 points
+             *)
+            IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF(cv) THEN
+              IF (SIZEOF (cv\polyline.points) >= 3) THEN RETURN (TRUE);
+              END_IF;
+            END_IF;
+          END_IF; 
+        END_IF; 
+      END_IF; 
+    END_IF; 
+  END_IF; 
+END_IF; 
+(* FALSE is returned if the input parameter cv is not a valid curve.
+ *)
+RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION msf_surface_check
+	(surf: surface) : BOOLEAN;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELEMENTARY_SURFACE' IN TYPEOF(surf) THEN
+    RETURN(TRUE);
+  ELSE 
+
+    (* a swept_surface shall have a valid sweeping curve
+     *)
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_SURFACE' IN TYPEOF (surf) THEN 
+      RETURN (msf_curve_check(surf\swept_surface.swept_curve));  
+    ELSE 
+ 
+      (* an offset_surface shall not self-intersect and shall
+         reference a valid surface
+       *)
+      IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_SURFACE' IN TYPEOF (surf)) AND
+        (surf\offset_surface.self_intersect = FALSE) OR 
+        (surf\offset_surface.self_intersect = UNKNOWN)) THEN
+        RETURN (msf_surface_check(surf\offset_surface.basis_surface));
+      ELSE 
+ 
+        (* a surface_replica shall have a valid parent surface
+         *)
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_REPLICA' IN TYPEOF(surf) THEN 
+          RETURN(msf_surface_check(surf\surface_replica.parent_surface)); 
+        ELSE
+
+          (* a b_spline_surface shall not self-intersect
+           *)
+          IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_SURFACE' IN TYPEOF(surf)) AND
+            (surf\b_spline_surface.self_intersect = FALSE) OR
+            (surf\b_spline_surface.self_intersect = UNKNOWN)) THEN
+            RETURN(TRUE);
+          END_IF;
+        END_IF; 
+      END_IF; 
+    END_IF; 
+  END_IF; 
+  RETURN(FALSE);
+END_FUNCTION;
+
+FUNCTION nmsf_curve_check
+	(cv: representation_item) : BOOLEAN;
+IF SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_CURVE',
+   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC',
+   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA',
+   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE',
+   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D'] * TYPEOF(cv)) > 1
+ THEN RETURN(FALSE);
+ ELSE
+
+  (* b_spline_curves shall not self-intersect
+   *)
+  IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' IN TYPEOF (cv)) AND
+    (cv\b_spline_curve.self_intersect = FALSE) OR
+    (cv\b_spline_curve.self_intersect = UNKNOWN))
+  THEN RETURN(TRUE);
+  ELSE
+
+    (* conics and lines are valid curve types
+     *)
+    IF SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC',
+    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE'] * TYPEOF (cv)) = 1 THEN
+      RETURN(TRUE);
+    ELSE
+
+      (* a curve_replica shall reference a valid curve
+       *)
+      IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA' IN TYPEOF(cv) THEN
+        RETURN (nmsf_curve_check(cv\curve_replica.parent_curve)); 
+      ELSE 
+ 
+        (* an offset_curve_3d shall not self-intersect and
+           shall reference a valid curve; a polyline is not a
+           valid basis_curve
+         *)
+        IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D' IN TYPEOF (cv)) 
+          AND
+          ((cv\offset_curve_3d.self_intersect = FALSE) OR
+          (cv\offset_curve_3d.self_intersect = UNKNOWN))
+          AND
+          (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF
+          (cv\offset_curve_3d.basis_curve)))) THEN
+          RETURN (nmsf_curve_check(cv\offset_curve_3d.basis_curve)); 
+        ELSE 
+ 
+          (* a pcurve shall reference a valid curve and a valid
+             basis_surface
+           *)
+          IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(cv) THEN 
+            RETURN ((nmsf_curve_check
+            (cv\pcurve.reference_to_curve\representation.items[1]))
+            AND
+            (nmsf_surface_check(cv\pcurve.basis_surface)));
+          ELSE 
+ 
+            (* a surface_curve references a curve_3d and one or
+               two pcurves or one or two surfaces or one of
+               each; all of these references shall be valid
+             *)
+            IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN TYPEOF(cv) THEN 
+
+              (* if the curve reference is correct, check also the rest
+               *)
+              IF nmsf_curve_check(cv\surface_curve.curve_3d) THEN
+                REPEAT i := 1 TO SIZEOF
+                (cv\surface_curve.associated_geometry);
+
+                  (* do for one or two associated_geometrys:
+                   *)
+                  IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE' IN 
+                    TYPEOF (cv\surface_curve.associated_geometry[i]) THEN  
+                    IF NOT nmsf_surface_check
+                      (cv\surface_curve.associated_geometry[i]) THEN  
+                      RETURN(FALSE);  
+                    END_IF;  
+                  ELSE  
+                    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF 
+                      (cv\surface_curve.associated_geometry[i]) THEN  
+                      IF NOT nmsf_curve_check
+                        (cv\surface_curve.associated_geometry[i]) THEN 
+                        RETURN(FALSE);  
+                      END_IF;  
+                    END_IF;  
+                  END_IF; 
+                END_REPEAT;  
+                RETURN(TRUE);
+              END_IF; 
+            ELSE
+
+              (* a polyline shall have at least 3 points 
+               *)
+              IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF(cv) THEN
+                IF (SIZEOF (cv\polyline.points) >= 3) THEN RETURN (TRUE);
+                END_IF;
+              END_IF;
+            END_IF; 
+          END_IF; 
+        END_IF; 
+      END_IF; 
+    END_IF; 
+  END_IF; 
+ END_IF; 
+ (* FALSE is returned if the input parameter cv is not a valid curve.
+  *)
+ RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION nmsf_surface_check
+	(surf: surface) : BOOLEAN;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELEMENTARY_SURFACE' IN TYPEOF(surf) THEN
+    RETURN(TRUE);
+  ELSE 
+
+    (* a swept_surface shall have a valid sweeping curve
+     *)
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_SURFACE' IN TYPEOF (surf) THEN 
+      RETURN (nmsf_curve_check(surf\swept_surface.swept_curve));  
+    ELSE 
+ 
+      (* an offset_surface shall not self-intersect and shall
+         reference a valid surface
+       *)
+      IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_SURFACE' IN TYPEOF (surf)) AND
+        (surf\offset_surface.self_intersect = FALSE) OR 
+        (surf\offset_surface.self_intersect = UNKNOWN)) THEN
+        RETURN (nmsf_surface_check(surf\offset_surface.basis_surface));
+      ELSE 
+ 
+        (* a surface_replica shall have a valid parent surface
+         *)
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_REPLICA' IN TYPEOF(surf) THEN 
+          RETURN(nmsf_surface_check(surf\surface_replica.parent_surface)); 
+        ELSE
+
+          (* a b_spline_surface shall not self-intersect
+           *)
+          IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_SURFACE' IN TYPEOF(surf))
+            AND
+            (surf\b_spline_surface.self_intersect = FALSE) OR
+            (surf\b_spline_surface.self_intersect = UNKNOWN)) THEN
+            RETURN(TRUE);
+          END_IF;
+        END_IF; 
+      END_IF; 
+    END_IF; 
+  END_IF; 
+  RETURN(FALSE);
+END_FUNCTION;
+
+FUNCTION normalise
+	(arg: vector_or_direction) : vector_or_direction;
+    LOCAL
+      ndim   : INTEGER;
+      v      : direction;
+      result : vector_or_direction;
+      vec    : vector;
+      mag    : REAL;
+    END_LOCAL;
+    
+    IF NOT EXISTS (arg) THEN
+      result := ?;
+  (* When function is called with invalid data a NULL result is returned *)
+    ELSE
+      ndim := arg.dim;
+      IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VECTOR' IN TYPEOF(arg) THEN
+        BEGIN
+              v := dummy_gri || direction(arg\vector.orientation.direction_ratios);
+          IF arg.magnitude = 0.0 THEN
+            RETURN(?);
+          ELSE
+           vec := dummy_gri || vector (v, 1.0);
+          END_IF;
+        END;
+      ELSE
+        v := dummy_gri || direction (arg.direction_ratios);
+      END_IF;
+      mag := 0.0;
+      REPEAT  i := 1 TO ndim;
+        mag := mag + v.direction_ratios[i]*v.direction_ratios[i];
+      END_REPEAT;
+      IF mag > 0.0 THEN
+        mag := SQRT(mag);
+        REPEAT  i := 1 TO ndim;
+          v.direction_ratios[i] := v.direction_ratios[i]/mag;
+        END_REPEAT;
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VECTOR' IN TYPEOF(arg) THEN
+          vec.orientation := v;
+          result := vec;
+        ELSE
+          result := v;
+        END_IF;
+      ELSE
+        RETURN(?);
+      END_IF;
+    END_IF;
+    RETURN (result);
+END_FUNCTION;
+
+FUNCTION open_shell_reversed
+	(a_shell: open_shell) : oriented_open_shell;
+   LOCAL
+     the_reverse : oriented_open_shell;
+   END_LOCAL;
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_OPEN_SHELL' IN TYPEOF (a_shell) ) THEN
+     the_reverse := dummy_tri ||
+                  connected_face_set (
+                      a_shell\connected_face_set.cfs_faces) ||
+                  open_shell () || oriented_open_shell(
+                    a_shell\oriented_open_shell.open_shell_element,
+                      (NOT (a_shell\oriented_open_shell.orientation)));
+   ELSE
+     the_reverse := dummy_tri ||
+                 connected_face_set (
+                     a_shell\connected_face_set.cfs_faces) ||
+                 open_shell () ||  oriented_open_shell (a_shell, FALSE);
+   END_IF;
+   RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION orthogonal_complement
+	(vec: direction) : direction;
+   LOCAL
+     result :  direction ;
+   END_LOCAL;
+
+   IF (vec.dim <> 2) OR NOT EXISTS (vec) THEN
+     RETURN(?);
+   ELSE
+     result := dummy_gri || direction([-vec.direction_ratios[2],
+                                          vec.direction_ratios[1]]);
+     RETURN(result);
+   END_IF;
+END_FUNCTION;
+
+FUNCTION path_head_to_tail
+	(a_path: path) : LOGICAL;
+   LOCAL
+     n : INTEGER;
+     p : LOGICAL := TRUE;
+   END_LOCAL;
+     
+     n := SIZEOF (a_path.edge_list);
+     REPEAT i := 2 TO n;
+       p := p AND (a_path.edge_list[i-1].edge_end :=:
+                   a_path.edge_list[i].edge_start);
+     END_REPEAT;
+     
+     RETURN (p);
+END_FUNCTION;
+
+FUNCTION path_reversed
+	(a_path: path) : oriented_path;
+  LOCAL
+    the_reverse : oriented_path ;
+  END_LOCAL;
+  IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_PATH' IN TYPEOF (a_path) ) THEN
+    the_reverse := dummy_tri ||
+       path(list_of_topology_reversed (a_path.edge_list)) ||
+          oriented_path(a_path\oriented_path.path_element,
+                          NOT(a_path\oriented_path.orientation)) ;
+  ELSE
+    the_reverse := dummy_tri ||
+                   path(list_of_topology_reversed (a_path.edge_list)) ||
+                       oriented_path(a_path, FALSE);
+  END_IF;
+
+  RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION scalar_times_vector
+	(scalar: REAL; vec: vector_or_direction) : vector;
+    LOCAL
+      v      : direction;
+      mag    : REAL;
+      result : vector;
+    END_LOCAL;
+ 
+    IF NOT EXISTS (scalar) OR NOT EXISTS (vec) THEN
+      RETURN (?) ;
+     ELSE
+      IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VECTOR' IN TYPEOF (vec) THEN
+        v   := dummy_gri || direction(vec\vector.orientation.direction_ratios);
+        mag := scalar * vec.magnitude;
+      ELSE
+        v   := dummy_gri || direction(vec.direction_ratios);
+        mag := scalar;
+      END_IF;
+      IF (mag < 0.0 ) THEN
+        REPEAT i := 1 TO SIZEOF(v.direction_ratios);
+          v.direction_ratios[i] := -v.direction_ratios[i];
+        END_REPEAT;
+        mag := -mag;
+      END_IF;
+      result := dummy_gri || vector(normalise(v), mag);
+    END_IF;
+    RETURN (result);
+END_FUNCTION;
+
+FUNCTION second_proj_axis
+	(z_axis: direction; x_axis: direction; arg: direction) : direction;
+   LOCAL
+     y_axis : vector;
+     v      : direction;
+     temp   : vector;
+   END_LOCAL;
+   
+   IF NOT EXISTS(arg) THEN
+     v := dummy_gri || direction([0.0,1.0,0.0]);
+   ELSE
+     v := arg;
+   END_IF;
+   
+   temp   := scalar_times_vector(dot_product(v, z_axis), z_axis);
+   y_axis := vector_difference(v, temp);
+   temp   := scalar_times_vector(dot_product(v, x_axis), x_axis);
+   y_axis := vector_difference(y_axis, temp);
+   y_axis := normalise(y_axis);
+   RETURN(y_axis.orientation);
+END_FUNCTION;
+
+FUNCTION set_of_topology_reversed
+	(a_set: set_of_reversible_topology_item) : set_of_reversible_topology_item;
+   LOCAL
+     the_reverse : set_of_reversible_topology_item;
+   END_LOCAL;
+   
+   the_reverse := [];
+   REPEAT i := 1 TO SIZEOF (a_set);
+     the_reverse := the_reverse + topology_reversed (a_set [i]);
+   END_REPEAT;
+   
+   RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION shell_reversed
+	(a_shell: shell) : shell;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OPEN_SHELL' IN TYPEOF (a_shell) ) THEN
+     RETURN (open_shell_reversed (a_shell));
+   ELSE
+     IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CLOSED_SHELL' IN TYPEOF (a_shell) ) THEN
+       RETURN (closed_shell_reversed (a_shell));
+     ELSE
+       RETURN (?);
+     END_IF;
+   END_IF;
+END_FUNCTION;
+
+FUNCTION surface_condition_correlation
+	(pd: property_definition; rep: representation) : LOGICAL;
+CASE pd.name OF
+      'visual appearance', 'tactile appearance', 'contact ratio', 'hardness', 'treatment result', 'surface texture' : 
+	  RETURN(pd.name = rep.name);
+      OTHERWISE : RETURN(UNKNOWN);
+    END_CASE;
+END_FUNCTION;
+
+FUNCTION surface_weights_positive
+	(b: rational_b_spline_surface) : BOOLEAN;
+   LOCAL
+     result        : BOOLEAN := TRUE;
+   END_LOCAL;
+   
+   REPEAT i := 0 TO b.u_upper;
+     REPEAT j := 0 TO b.v_upper;
+       IF (b.weights[i][j] <= 0.0)  THEN
+         result := FALSE;
+         RETURN(result);
+       END_IF;
+     END_REPEAT;
+   END_REPEAT;
+   RETURN(result);
+END_FUNCTION;
+
+FUNCTION topology_reversed
+	(an_item: reversible_topology) : reversible_topology;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE' IN TYPEOF (an_item)) THEN
+     RETURN (edge_reversed (an_item));
+   END_IF;
+
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PATH' IN TYPEOF (an_item)) THEN
+     RETURN (path_reversed (an_item));
+   END_IF;
+
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BOUND' IN TYPEOF (an_item)) THEN
+     RETURN (face_bound_reversed (an_item));
+   END_IF;
+  
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE' IN TYPEOF (an_item)) THEN
+     RETURN (face_reversed (an_item));
+   END_IF;
+
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL' IN TYPEOF (an_item)) THEN
+     RETURN (shell_reversed (an_item));
+   END_IF;
+
+   IF ('SET' IN TYPEOF (an_item)) THEN
+     RETURN (set_of_topology_reversed (an_item));
+   END_IF;
+
+   IF ('LIST' IN TYPEOF (an_item)) THEN
+     RETURN (list_of_topology_reversed (an_item));
+   END_IF;
+
+   RETURN (?);
+END_FUNCTION;
+
+FUNCTION type_check_function
+	(the_type: GENERIC; sub_names: SET [0:?] OF STRING; criterion: INTEGER) : LOGICAL;
+IF ((NOT EXISTS(the_type)) OR (NOT ({0 <= criterion <= 3})) OR (SIZEOF(sub_names) = 0)) THEN
+      RETURN (UNKNOWN);
+    ELSE
+      CASE criterion OF 
+        0:
+          RETURN (SIZEOF(sub_names * TYPEOF(the_type)) > 0);
+        1:
+          RETURN (SIZEOF(sub_names * TYPEOF(the_type)) = 0);
+        2:
+          RETURN (SIZEOF(sub_names * TYPEOF(the_type)) = 1);
+        3:
+          RETURN (SIZEOF(sub_names * TYPEOF(the_type)) <= 1);
+      END_CASE;
+    END_IF;
+END_FUNCTION;
+
+FUNCTION using_items
+	(item: founded_item_select; checked_items: SET [0:?] OF founded_item_select) : SET [0:?] OF founded_item_select;
+    LOCAL
+      new_check_items    : SET OF founded_item_select;
+      result_items       : SET OF founded_item_select;
+      next_items         : SET OF founded_item_select;
+    END_LOCAL;
+    result_items := [];
+    new_check_items := checked_items + item;
+    -- Find the set of representation_items or founded_items
+    -- in which item is used directly.
+    next_items := QUERY(z <* bag_to_set( USEDIN(item , '')) |
+      ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION_ITEM' IN TYPEOF(z)) OR
+      ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FOUNDED_ITEM'        IN TYPEOF(z)));
+    -- If the set of next_items is not empty;
+    IF SIZEOF(next_items) > 0 THEN
+      -- For each element in the set, find the using_items recursively
+      REPEAT i := 1 TO HIINDEX(next_items);
+        -- Check for loop in data model, i.e. one of the next_items
+        -- occurred earlier in the set of check_items;
+        IF NOT(next_items[i] IN new_check_items) THEN
+          result_items := result_items + next_items[i] +
+                          using_items(next_items[i],new_check_items);
+        END_IF;
+      END_REPEAT;
+    END_IF;
+    -- return the set of representation_items or founded_items
+    -- in which the input item is used directly and indirectly.
+    RETURN (result_items);
+END_FUNCTION;
+
+FUNCTION using_representations
+	(item: founded_item_select) : SET [0:?] OF representation;
+    LOCAL
+      results            : SET OF representation;
+      result_bag         : BAG OF representation;
+      intermediate_items : SET OF founded_item_select;
+    END_LOCAL;
+    -- Find the representations in which the item is used and add to the
+    -- results set.
+    results := [];
+    result_bag := USEDIN(item,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION.ITEMS');
+    IF SIZEOF(result_bag) > 0 THEN
+      REPEAT i := 1 TO HIINDEX(result_bag);
+        results := results + result_bag[i];
+      END_REPEAT;
+    END_IF;
+    -- Find all representation_items or founded_items
+    -- by which item is referenced directly or indirectly.
+    intermediate_items := using_items(item,[]);
+    -- If the set of intermediate items is not empty;
+    IF SIZEOF(intermediate_items) > 0 THEN
+      -- For each element in the set, add the
+      -- representations of that element.
+      REPEAT i := 1 TO HIINDEX(intermediate_items);
+        result_bag := USEDIN(intermediate_items[i],
+                      'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION.ITEMS');
+        IF SIZEOF(result_bag) > 0 THEN
+          REPEAT j := 1 TO HIINDEX(result_bag);
+            results := results + result_bag[j];
+          END_REPEAT;
+        END_IF;
+      END_REPEAT;
+    END_IF;
+    -- Return the set of representation in which the input item is
+    -- used directly and indirectly (through intervening
+    -- representation_items or founded items).
+    RETURN (results);
+END_FUNCTION;
+
+FUNCTION valid_basis_curve_in_2d_wireframe
+	(crv: curve) : BOOLEAN;
+IF SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE',
+               'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE',
+               'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELLIPSE',
+               'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCLE'] * 
+               TYPEOF (crv)) = 1
+    THEN RETURN (TRUE);
+  ELSE
+    -- if the curve is a trimmed_curve
+    IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TRIMMED_CURVE') 
+    IN TYPEOF (crv)) THEN
+      -- if a line, parabola, or hyperbola is being trimmed, then valid
+      IF SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE',
+                   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PARABOLA',
+                   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.HYPERBOLA'] *
+           TYPEOF(crv\trimmed_curve.basis_curve)) = 1
+        THEN RETURN (TRUE);
+      -- otherwise, recursively check basis_curve
+      ELSE RETURN (valid_basis_curve_in_2d_wireframe
+                         (crv\trimmed_curve.basis_curve));
+      END_IF;
+    ELSE
+      -- recursively check the offset_curve basis curve
+      IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_2D') 
+      IN TYPEOF (crv))
+        THEN RETURN (valid_basis_curve_in_2d_wireframe
+                           (crv\offset_curve_2d.basis_curve));
+      ELSE
+        -- recursively check the curve_replica parent curve
+        IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA') 
+        IN TYPEOF (crv))
+          THEN RETURN (valid_basis_curve_in_2d_wireframe
+                         (crv\curve_replica.parent_curve));
+        ELSE
+          -- recursively check the composite_curve segments
+          IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE') 
+          IN TYPEOF (crv)) THEN
+            RETURN (SIZEOF (QUERY (ccs <* crv\composite_curve.segments |
+                      NOT (valid_basis_curve_in_2d_wireframe
+                             (ccs.parent_curve)))) = 0);
+          END_IF;
+        END_IF;
+      END_IF;
+    END_IF;
+  END_IF;
+  RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION valid_calendar_date
+	(date: calendar_date) : LOGICAL;
+CASE date.month_component OF
+    1  : RETURN({ 1 <= date.day_component <= 31 });
+    2  : BEGIN
+           IF (leap_year(date.year_component)) THEN
+             RETURN({ 1 <= date.day_component <= 29 });
+           ELSE
+             RETURN({ 1 <= date.day_component <= 28 });
+           END_IF;
+         END;
+    3  : RETURN({ 1 <= date.day_component <= 31 });
+    4  : RETURN({ 1 <= date.day_component <= 30 });
+    5  : RETURN({ 1 <= date.day_component <= 31 });
+    6  : RETURN({ 1 <= date.day_component <= 30 });
+    7  : RETURN({ 1 <= date.day_component <= 31 });
+    8  : RETURN({ 1 <= date.day_component <= 31 });
+    9  : RETURN({ 1 <= date.day_component <= 30 });
+    10 : RETURN({ 1 <= date.day_component <= 31 });
+    11 : RETURN({ 1 <= date.day_component <= 30 });
+    12 : RETURN({ 1 <= date.day_component <= 31 });
+  END_CASE;
+  RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION valid_datum_target_parameters
+	(pdf: placed_datum_target_feature) : BOOLEAN;
+LOCAL
+
+rep_set : SET OF representation := [] ;
+
+parameter_representations: SET OF representation;
+END_LOCAL;
+
+
+REPEAT i := 1 TO HIINDEX(pdf.representation_associations);
+rep_set := rep_set + pdf.representation_associations[i].used_representation;
+END_REPEAT;
+ 
+parameter_representations := QUERY(rep <* rep_set |
+('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION_WITH_PARAMETERS' IN
+TYPEOF(rep)));
+
+
+IF (SIZEOF( QUERY( srwp <* parameter_representations |
+          (SIZEOF( QUERY( i <* srwp.items |
+          (i.name='orientation') AND
+          ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLACEMENT' IN TYPEOF(i)))) = 1))) <> 1) THEN
+   RETURN(FALSE);
+END_IF;
+
+CASE pdf\shape_aspect.description OF
+'point': RETURN(SIZEOF(QUERY( srwp <* parameter_representations |
+              (SIZEOF(srwp.items) = 1))) = 1);
+
+'circle': RETURN((SIZEOF( QUERY( srwp <* parameter_representations |
+              (SIZEOF(srwp.items) = 2))) = 1) AND
+             (SIZEOF( QUERY( srwp <* parameter_representations |
+              (SIZEOF( QUERY( i <* srwp.items |
+                (i.name='target diameter') AND
+                (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM',
+		   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE_WITH_UNIT']*TYPEOF(i)
+                 ) = 2) )) = 1))) = 1));
+
+'line': RETURN(SIZEOF( QUERY( srwp <* parameter_representations |
+              (SIZEOF( QUERY( i <* srwp.items |
+                (i.name='target length') AND
+                (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM',
+		'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE_WITH_UNIT']*TYPEOF(i)
+                 ) = 2) )) = 1))) = 1);
+
+'rectangle': RETURN((SIZEOF( QUERY( srwp <* parameter_representations |
+              (SIZEOF(srwp.items)= 3))) = 1) AND
+             (SIZEOF( QUERY( srwp <* parameter_representations |
+              (SIZEOF( QUERY( i <* srwp.items |
+                (i.name='target length') AND
+                (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM',
+		'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE_WITH_UNIT']*TYPEOF(i)
+                 ) = 2))) = 1))) = 1) AND
+              (SIZEOF( QUERY( srwp <* parameter_representations |
+               (SIZEOF( QUERY( i <* srwp.items |
+                 (i.name='target width') AND
+                 (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM',
+ 		'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE_WITH_UNIT']*TYPEOF(i)
+                  ) = 2))) = 1) )) = 1));
+OTHERWISE : RETURN(FALSE);
+END_CASE;
+END_FUNCTION;
+
+FUNCTION valid_geometrically_bounded_wf_curve
+	(crv: curve) : BOOLEAN;
+IF SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELLIPSE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCLE' ] * TYPEOF (crv)) = 1 THEN 
+ RETURN (TRUE);
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TRIMMED_CURVE' IN TYPEOF (crv) THEN 
+ IF SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PARABOLA', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.HYPERBOLA' ] * TYPEOF (crv\trimmed_curve.basis_curve)) = 1 THEN 
+ RETURN (TRUE);
+ ELSE 
+ RETURN (valid_geometrically_bounded_wf_curve(crv\trimmed_curve.basis_curve));
+ END_IF ;
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D' IN TYPEOF (crv) THEN 
+ RETURN (valid_geometrically_bounded_wf_curve(crv\offset_curve_3d.basis_curve));
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA' IN TYPEOF (crv) THEN 
+ RETURN (valid_geometrically_bounded_wf_curve(crv\curve_replica.parent_curve));
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE' IN TYPEOF (crv) THEN 
+ RETURN ( SIZEOF ( 
+QUERY ( ccs <* crv\composite_curve.segments| NOT valid_geometrically_bounded_wf_curve(ccs.parent_curve) )) = 0);
+ END_IF ;
+ END_IF ;
+ END_IF ;
+ END_IF ;
+ END_IF ;
+ RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION valid_geometrically_bounded_wf_point
+	(pnt: point) : BOOLEAN;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF (pnt) THEN 
+ RETURN (TRUE);
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE' IN TYPEOF (pnt) THEN 
+ RETURN (valid_geometrically_bounded_wf_curve(pnt\point_on_curve.basis_curve));
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_REPLICA' IN TYPEOF (pnt) THEN 
+ RETURN (valid_geometrically_bounded_wf_point(pnt\point_replica.parent_pt));
+ END_IF ;
+ END_IF ;
+ END_IF ;
+ RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION valid_measure_value
+	(m: measure_value) : BOOLEAN;
+IF ('REAL' IN TYPEOF (m)) THEN
+    RETURN (m > 0.0);
+    ELSE
+     IF ('INTEGER' IN TYPEOF (m)) THEN
+      RETURN (m > 0);
+      ELSE
+        RETURN (TRUE);
+      END_IF;
+    END_IF;
+END_FUNCTION;
+
+FUNCTION valid_selected_instance_representation
+	(pd: product_definition_or_assembly_relationship) : LOGICAL;
+    LOCAL
+      properties: SET OF property_definition := bag_to_set(QUERY( prd<* USEDIN ( pd ,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROPERTY_DEFINITION.DEFINITION' ) | 
+        (prd.name = 'occurrence selection' )));
+      property_definition_representations: SET OF property_definition_representation := bag_to_set(QUERY ( pdr <* USEDIN ( properties[1] , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROPERTY_DEFINITION_REPRESENTATION.DEFINITION') | 
+	    ( pdr.used_representation.name = 'selection criteria' )));
+      selected_representation: representation;
+    END_LOCAL;
+    IF (SIZEOF( properties)<>1) THEN
+	  RETURN(FALSE);
+    END_IF;
+    IF (SIZEOF(property_definition_representations)<>1) THEN
+	  RETURN(FALSE);
+    END_IF;
+    selected_representation := property_definition_representations[1]\property_definition_representation.used_representation;
+    IF (SIZEOF(selected_representation\representation.items) <1) OR (SIZEOF(selected_representation\representation.items) >2) THEN
+	  RETURN(FALSE);
+    END_IF;
+    IF (SIZEOF ( QUERY ( i <* selected_representation\representation.items |
+	  ( SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' ,
+      'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VALUE_RANGE']* TYPEOF ( i ) ) = 1) AND
+      ( i.name = 'selection quantity' ))) <> 1 ) THEN
+      RETURN(FALSE);
+    END_IF;
+    IF (SIZEOF ( QUERY ( i <* selected_representation\representation.items |
+	  ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF ( i ) ) AND
+ 	  ( i.name = 'selection control' )))> 1) THEN
+	  RETURN(FALSE);
+    END_IF; --the selection control is not specified then the quantity shall be a qualified_representation_item or a value_range
+    IF (SIZEOF ( QUERY ( i <* selected_representation\representation.items |
+      ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF( i ) ) AND
+      ( i.name = 'selection control' ) ))= 0) AND 
+      (SIZEOF ( QUERY ( i <* selected_representation\representation.items |
+      ( i.name = 'selection quantity' ) AND  
+      ( SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.QUALIFIED_REPRESENTATION_ITEM' ,
+      'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VALUE_RANGE']* TYPEOF ( i ) ) =0 ))) > 0 ) THEN
+	  RETURN(FALSE);
+    END_IF;
+    RETURN(TRUE);
+END_FUNCTION;
+
+FUNCTION valid_time
+	(time: local_time) : BOOLEAN;
+IF EXISTS(time.second_component) THEN
+    RETURN (EXISTS(time.minute_component));
+  ELSE
+    RETURN (TRUE);
+  END_IF;
+END_FUNCTION;
+
+FUNCTION valid_units
+	(m: measure_with_unit) : BOOLEAN;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MASS_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TIME_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELECTRIC_CURRENT_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.THERMODYNAMIC_TEMPERATURE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CELSIUS_TEMPERATURE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AMOUNT_OF_SUBSTANCE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LUMINOUS_INTENSITY_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE_ANGLE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_ANGLE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AREA_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VOLUME_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(3.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RATIO_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_PLANE_ANGLE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ACCELERATION_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 1.0, 0.0, -2.0, 0.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+     IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CAPACITANCE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( -2.0, -1.0, 4.0, 1.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELECTRIC_CHARGE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONDUCTANCE_MEASURE' IN TYPEOF(m.value_component) THEN
+          IF derive_dimensional_exponents(m.unit_component) <> 
+            dimensional_exponents( -2.0, -1.0, 3.0, 2.0, 0.0, 0.0, 0.0 ) THEN
+            RETURN (FALSE);
+          END_IF;
+    END_IF;
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELECTRIC_POTENTIAL_MEASURE' IN TYPEOF(m.value_component) THEN
+          IF derive_dimensional_exponents(m.unit_component) <> 
+            dimensional_exponents( 2.0, 1.0, -3.0, -1.0, 0.0, 0.0, 0.0 ) THEN
+            RETURN (FALSE);
+          END_IF;
+    END_IF;    
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ENERGY_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 2.0, 1.0, -2.0, 0.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FORCE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 1.0, 1.0, -2.0, 0.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FREQUENCY_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ILLUMINANCE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( -2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+     IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INDUCTANCE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 2.0, 1.0, -2.0, -2.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LUMINOUS_FLUX_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAGNETIC_FLUX_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 2.0, 1.0, -2.0, -1.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+     IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAGNETIC_FLUX_DENSITY_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 0.0, 1.0, -2.0, -1.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POWER_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 2.0, 1.0, -3.0, 0.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESSURE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( -1.0, 1.0, -2.0, 0.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RESISTANCE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 2.0, 1.0, -3.0, -2.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VELOCITY_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RADIOACTIVITY_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents(0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ABSORBED_DOSE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents(2.0, 0.0, -2.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DOSE_EQUIVALENT_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents(2.0, 0.0, -2.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    RETURN (TRUE);
+END_FUNCTION;
+
+FUNCTION valid_wireframe_edge_curve
+	(crv: curve) : BOOLEAN;
+IF SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' ] * TYPEOF (crv)) = 1 THEN 
+ RETURN (TRUE);
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA' IN TYPEOF (crv) THEN 
+ RETURN (valid_wireframe_edge_curve(crv\curve_replica.parent_curve));
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D' IN TYPEOF (crv) THEN 
+ RETURN (valid_wireframe_edge_curve(crv\offset_curve_3d.basis_curve));
+ END_IF ;
+ END_IF ;
+ END_IF ;
+ RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION valid_wireframe_vertex_point
+	(pnt: point) : BOOLEAN;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF (pnt) THEN 
+ RETURN (TRUE);
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_REPLICA' IN TYPEOF (pnt) THEN 
+ RETURN (valid_wireframe_vertex_point(pnt\point_replica.parent_pt));
+ END_IF ;
+ END_IF ;
+ RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION validate_countersink_radii
+	(cskhole: solid_with_stepped_round_hole_and_conical_transitions) : BOOLEAN;
+  LOCAL
+    i,j             : INTEGER;
+    n               : INTEGER := 1 +
+                        cskhole\solid_with_stepped_round_hole.segments;
+    smaller, larger : positive_length_measure;
+  END_LOCAL;
+
+  REPEAT i := 1 TO SIZEOF(cskhole.conical_transitions);
+
+  -- First check whether transition i applies to the entry of the hole or 
+  -- the exit of a through hole - those cases only need to be checked for 
+  -- the sign of the cone apex angle.
+
+  IF (((cskhole.conical_transitions[i].transition_number = 1)
+       AND (cskhole.conical_transitions[i].cone_apex_angle < 0))
+    XOR ((cskhole.conical_transitions[i].transition_number = n)
+         AND (cskhole.conical_transitions[i].cone_apex_angle > 0))) 
+  THEN RETURN(FALSE); 
+  ELSE
+    IF ((cskhole.conical_transitions[i].transition_number <> 1)
+      AND (cskhole.conical_transitions[i].transition_number <> n))
+    THEN
+
+  -- For all remaining transitions, check that the cone base radius 
+  -- lies in the range of validity.
+
+
+      BEGIN
+        j := cskhole.conical_transitions[i].transition_number;
+        IF cskhole\solid_with_stepped_round_hole.segment_radii[j] 
+          > cskhole\solid_with_stepped_round_hole.segment_radii[j-1]
+        THEN 
+          BEGIN
+            IF (cskhole.conical_transitions[i].cone_apex_angle > 0)
+            THEN RETURN(FALSE);
+            END_IF;
+            larger 
+              := cskhole\solid_with_stepped_round_hole.segment_radii[j];
+            smaller 
+              := cskhole\solid_with_stepped_round_hole.segment_radii[j-1];
+          END;
+        ELSE
+          BEGIN
+            IF (cskhole.conical_transitions[i].cone_apex_angle < 0)
+            THEN RETURN(FALSE);
+            END_IF;
+            larger  
+              := cskhole\solid_with_stepped_round_hole.segment_radii[j-1];
+            smaller 
+              := cskhole\solid_with_stepped_round_hole.segment_radii[j];
+          END;
+        END_IF; 
+        IF ((cskhole.conical_transitions[i].cone_base_radius > larger)
+          OR (cskhole.conical_transitions[i].cone_base_radius < smaller))
+        THEN RETURN(FALSE);
+        END_IF;
+      END;
+    END_IF;
+  END_IF;
+  END_REPEAT;
+  RETURN(TRUE);
+END_FUNCTION;
+
+FUNCTION value_range_aggregate_rep_item
+	(agg: AGGREGATE OF representation_item) : BOOLEAN;
+BEGIN 
+  IF (SIZEOF(QUERY(i1 <* agg | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'MEASURE_REPRESENTATION_ITEM' IN TYPEOF(i1)) )) = 6) THEN 
+	  RETURN (TRUE); 
+   ELSE 
+	RETURN (FALSE); 
+   END_IF; 
+   END;
+END_FUNCTION;
+
+FUNCTION value_range_wr1
+	(agg: compound_item_definition) : BOOLEAN;
+BEGIN
+      IF (SIZEOF(agg) = 2) AND ((SIZEOF(QUERY (i1 <* agg | (
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF
+        (i1)))) = 2) OR
+        (SIZEOF(QUERY (i2 <* agg | (
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VALUE_REPRESENTATION_ITEM' IN TYPEOF
+        (i2)))) = 2)) 
+      THEN
+        RETURN(TRUE);
+      ELSE
+        RETURN(FALSE);
+      END_IF;
+    END;
+END_FUNCTION;
+
+FUNCTION value_range_wr2
+	(agg: compound_item_definition) : BOOLEAN;
+BEGIN
+      IF ((SIZEOF(QUERY (i <* agg | (i\representation_item.name = 'upper limit'))) = 1)
+        AND (SIZEOF(QUERY (i <* agg | (i\representation_item.name = 'lower limit'))) = 1))
+      THEN
+        RETURN(TRUE);
+      ELSE
+        RETURN(FALSE);
+      END_IF;
+    END;
+END_FUNCTION;
+
+FUNCTION value_range_wr3
+	(agg: compound_item_definition) : BOOLEAN;
+BEGIN
+      IF (SIZEOF(QUERY(i1 <* agg |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF (i1)) AND
+        (SIZEOF (QUERY (i2 <* agg |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF (i2)) AND
+        (i1 :<>: i2) AND (i1\measure_with_unit.unit_component :=: i2\measure_with_unit.unit_component))) = 1))) = 2)
+      THEN
+        RETURN (TRUE);
+      ELSE
+        RETURN (FALSE);
+      END_IF;
+    END;
+END_FUNCTION;
+
+FUNCTION vector_difference
+	(arg1: vector_or_direction; arg2: vector_or_direction) : vector;
+    LOCAL
+      result          : vector;
+      res, vec1, vec2 : direction;
+      mag, mag1, mag2 : REAL;
+      ndim            : INTEGER;
+    END_LOCAL;
+ 
+    IF ((NOT EXISTS (arg1)) OR (NOT EXISTS (arg2))) OR (arg1.dim <> arg2.dim)
+        THEN
+      RETURN (?) ;
+     ELSE
+      BEGIN
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VECTOR' IN TYPEOF(arg1) THEN
+          mag1 := arg1.magnitude;
+          vec1 := arg1\vector.orientation;
+        ELSE
+          mag1 := 1.0;
+          vec1 := arg1;
+        END_IF;
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VECTOR' IN TYPEOF(arg2) THEN
+          mag2 := arg2.magnitude;
+          vec2 := arg2\vector.orientation;
+        ELSE
+          mag2 := 1.0;
+          vec2 := arg2;
+        END_IF;
+        vec1 := normalise (vec1);
+        vec2 := normalise (vec2);
+        ndim := SIZEOF(vec1.direction_ratios);
+        mag := 0.0;
+        res := dummy_gri || direction(vec1.direction_ratios);
+        REPEAT i := 1 TO ndim;
+          res.direction_ratios[i] := mag1*vec1.direction_ratios[i] -
+                                      mag2*vec2.direction_ratios[i];
+          mag := mag + (res.direction_ratios[i]*res.direction_ratios[i]);
+        END_REPEAT;
+        IF (mag > 0.0 ) THEN
+        result := dummy_gri || vector( res, SQRT(mag));
+        ELSE
+          result := dummy_gri || vector( vec1,  0.0);
+        END_IF;
+      END;
+    END_IF;
+    RETURN (result);
+END_FUNCTION;
+
+END_SCHEMA; 
+

test/CMakeLists.txt

@@ -40,8 +40,9 @@
 cmake_minimum_required( VERSION 2.6 )
 
 INCLUDE_DIRECTORIES(
-	../contrib/gtest/include
-	../contrib/gtest/
+	${Assimp_SOURCE_DIR}/contrib/gtest/include
+	${Assimp_SOURCE_DIR}/contrib/gtest/
+    ${Assimp_SOURCE_DIR}/test/unit
     ${Assimp_SOURCE_DIR}/include
     ${Assimp_SOURCE_DIR}/code
 )
@@ -74,6 +75,7 @@ SET( COMMON
   unit/utProfiler.cpp
   unit/utSharedPPData.cpp
   unit/utStringUtils.cpp
+  unit/Common/utLineSplitter.cpp
 )
 
 SET( IMPORTERS
@@ -113,6 +115,8 @@ SET( IMPORTERS
   unit/utColladaImportExport.cpp
   unit/utCSMImportExport.cpp
   unit/utB3DImportExport.cpp
+  unit/utMDCImportExport.cpp
+  unit/utAssbinImportExport.cpp
 )
 
 SET( MATERIAL

test/models/OBJ/point_cloud.obj

@@ -0,0 +1,17 @@
+####
+#
+# OBJ File Generated by Meshlab
+#
+####
+# Object up.obj
+#
+# Vertices: 3
+# Faces: 0
+#
+####
+vn -0.281034 -0.057252 0.957989
+v -0.207717 -0.953997 2.554110
+vn -0.139126 -0.135672 0.980937
+v -0.275607 -0.965401 2.541530
+vn -0.163133 -0.131576 0.977791
+v -0.270155 -0.963170 2.548000

test/models/ParsingFiles/linesplitter_emptyline_test.txt

@@ -0,0 +1,3 @@
+TEST
+
+the rest

test/models/ParsingFiles/linesplitter_tokenizetest.txt

@@ -0,0 +1,12 @@
+#1= IFCORGANIZATION('GS','Graphisoft','Graphisoft',$,$);
+#5= IFCAPPLICATION(#1,'14.0','ArchiCAD 14.0','ArchiCAD');
+#6= IFCPERSON('','Haefele','Karl-Heinz',$,$,$,$,$);
+#8= IFCORGANIZATION('','KIT / IAI','',$,$);
+#12= IFCPERSONANDORGANIZATION(#6,#8,$);
+#13= IFCOWNERHISTORY(#12,#5,$,.ADDED.,$,$,$,1286451639);
+#14= IFCSIUNIT(*,.LENGTHUNIT.,$,.METRE.);
+#15= IFCSIUNIT(*,.AREAUNIT.,$,.SQUARE_METRE.);
+#16= IFCSIUNIT(*,.VOLUMEUNIT.,$,.CUBIC_METRE.);
+#17= IFCSIUNIT(*,.PLANEANGLEUNIT.,$,.RADIAN.);
+#18= IFCMEASUREWITHUNIT(IFCPLANEANGLEMEASURE(0.017453293),#17);
+

test/unit/Common/utLineSplitter.cpp

@@ -0,0 +1,71 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, 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.
+---------------------------------------------------------------------------
+*/
+#include "UnitTestPCH.h"
+
+#include <assimp/LineSplitter.h>
+#include <assimp/DefaultIOSystem.h>
+#include <string>
+
+using namespace Assimp;
+
+class utLineSplitter : public ::testing::Test {
+    // empty
+};
+
+TEST_F(utLineSplitter, tokenizetest) {
+    DefaultIOSystem fs;
+    IOStream* file = fs.Open(ASSIMP_TEST_MODELS_DIR"/ParsingFiles/linesplitter_tokenizetest.txt", "rb");
+
+    StreamReaderLE stream(file);
+    LineSplitter myLineSplitter(stream);
+}
+
+TEST_F( utLineSplitter, issue212Test) {
+    DefaultIOSystem fs;
+    IOStream* file = fs.Open(ASSIMP_TEST_MODELS_DIR"/ParsingFiles/linesplitter_emptyline_test.txt", "rb");
+
+    StreamReaderLE stream(file);
+    LineSplitter myLineSplitter(stream);
+    myLineSplitter++;
+    EXPECT_THROW( myLineSplitter++, std::logic_error );
+}

test/unit/utAssbinImportExport.cpp

@@ -0,0 +1,78 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, 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.
+---------------------------------------------------------------------------
+*/
+#include "UnitTestPCH.h"
+#include "SceneDiffer.h"
+#include "AbstractImportExportBase.h"
+#include <assimp/Importer.hpp>
+#include <assimp/Exporter.hpp>
+#include <assimp/postprocess.h>
+
+using namespace Assimp;
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+
+class utAssbinImportExport : public AbstractImportExportBase {
+public:
+    virtual bool importerTest() {
+        Assimp::Importer importer;
+        const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/OBJ/spider.obj", aiProcess_ValidateDataStructure );
+
+        Exporter exporter;
+        EXPECT_EQ( aiReturn_SUCCESS, exporter.Export( scene, "assbin", ASSIMP_TEST_MODELS_DIR "/OBJ/spider_test.assbin" ) );
+        const aiScene *newScene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/OBJ/spider_test.assbin", aiProcess_ValidateDataStructure );
+
+        return newScene != nullptr;
+    }
+};
+
+TEST_F( utAssbinImportExport, exportAssbin3DFromFileTest ) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/OBJ/spider.obj", aiProcess_ValidateDataStructure );
+    EXPECT_NE( nullptr, scene );
+}
+
+TEST_F( utAssbinImportExport, import3ExportAssbinDFromFileTest ) {
+    EXPECT_TRUE( importerTest() );
+}
+
+#endif // #ifndef ASSIMP_BUILD_NO_EXPORT

test/unit/utMDCImportExport.cpp

@@ -0,0 +1,63 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, 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.
+---------------------------------------------------------------------------
+*/
+
+#include "UnitTestPCH.h"
+#include "AbstractImportExportBase.h"
+#include <assimp/Importer.hpp>
+#include <assimp/postprocess.h>
+
+using namespace Assimp;
+
+class utMDCImportExport : public AbstractImportExportBase {
+public:
+    virtual bool importerTest() {
+        Assimp::Importer importer;
+        const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/MDC/spider.mdc", 0);
+        return true;
+        return nullptr != scene;
+    }
+};
+
+TEST_F( utMDCImportExport, importMDCFromFileTest ) {
+    EXPECT_TRUE( importerTest() );
+}

test/unit/utMaterialSystem.cpp

@@ -129,18 +129,10 @@ TEST_F(MaterialSystemTest, testStringProperty) {
     EXPECT_STREQ("Hello, this is a small test", s.data);
 }
 
-// ------------------------------------------------------------------------------------------------
-TEST_F(MaterialSystemTest, testDefaultMaterialAccess) {
-    aiMaterial *mat = aiCreateAndRegisterDefaultMaterial();
-    EXPECT_NE(nullptr, mat);
-    aiReleaseDefaultMaterial();
-
-    delete mat;
-}
 
 // ------------------------------------------------------------------------------------------------
 TEST_F(MaterialSystemTest, testMaterialNameAccess) {
-    aiMaterial *mat = aiCreateAndRegisterDefaultMaterial();
+    aiMaterial *mat = new aiMaterial();
     EXPECT_NE(nullptr, mat);
 
     aiString name = mat->GetName();

test/unit/utObjImportExport.cpp

@@ -389,3 +389,10 @@ TEST_F( utObjImportExport, mtllib_after_g ) {
     ASSERT_EQ(aiReturn_SUCCESS, mat->Get(AI_MATKEY_NAME, name));
     EXPECT_STREQ("MyMaterial", name.C_Str());
 }
+
+TEST_F(utObjImportExport, import_point_cloud) {
+    ::Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/OBJ/point_cloud.obj", 0 );
+    ASSERT_NE(nullptr, scene);
+}
+

test/unit/utSTLImportExport.cpp

@@ -67,6 +67,20 @@ TEST_F( utSTLImporterExporter, importSTLFromFileTest ) {
     EXPECT_TRUE( importerTest() );
 }
 
+
+TEST_F(utSTLImporterExporter, test_multiple) {
+    // import same file twice, each with its own importer
+    // must work both times and not crash
+    Assimp::Importer importer1;
+    const aiScene *scene1 = importer1.ReadFile( ASSIMP_TEST_MODELS_DIR "/STL/Spider_ascii.stl", aiProcess_ValidateDataStructure );
+    EXPECT_NE(nullptr, scene1);
+
+    Assimp::Importer importer2;
+    const aiScene *scene2 = importer2.ReadFile( ASSIMP_TEST_MODELS_DIR "/STL/Spider_ascii.stl", aiProcess_ValidateDataStructure );
+    EXPECT_NE(nullptr, scene2);
+}
+
+
 TEST_F( utSTLImporterExporter, test_with_two_solids ) {
     Assimp::Importer importer;
     const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/STL/triangle_with_two_solids.stl", aiProcess_ValidateDataStructure );

tools/assimp_qt_viewer/CMakeLists.txt

@@ -3,52 +3,28 @@ project(assimp_qt_viewer)
 
 cmake_minimum_required(VERSION 2.6)
 
-OPTION( ASSIMP_QT4_VIEWER
-	"Set to ON to enable Qt4 against Qt5 for assimp_qt_viewer"
-	OFF
-)
-
-FIND_PACKAGE(DevIL QUIET)
 FIND_PACKAGE(OpenGL QUIET)
 
-IF(ASSIMP_QT4_VIEWER)
-	# Qt4 version
-	FIND_PACKAGE(Qt4 QUIET)
-ELSE(ASSIMP_QT4_VIEWER)
-	# Qt5 version
-	FIND_PACKAGE(Qt5 COMPONENTS Gui Widgets OpenGL QUIET)
-ENDIF(ASSIMP_QT4_VIEWER)
+# Qt5 version
+FIND_PACKAGE(Qt5 COMPONENTS Gui Widgets OpenGL QUIET)
 
 SET(VIEWER_BUILD:BOOL FALSE)
 
-IF((Qt4_FOUND OR Qt5Widgets_FOUND) AND IL_FOUND AND OPENGL_FOUND)
+IF(  Qt5Widgets_FOUND AND OPENGL_FOUND)
 	SET(VIEWER_BUILD TRUE)
-
-ELSE((Qt4_FOUND OR Qt5Widgets_FOUND) AND IL_FOUND AND OPENGL_FOUND)
+ELSE( Qt5Widgets_FOUND AND OPENGL_FOUND)
 	SET ( ASSIMP_QT_VIEWER_DEPENDENCIES "")
 
-	IF(ASSIMP_QT4_VIEWER)
-		IF (NOT Qt4_FOUND)
-			SET ( ASSIMP_QT_VIEWER_DEPENDENCIES "${ASSIMP_QT_VIEWER_DEPENDENCIES} Qt4")
-		ENDIF (NOT Qt4_FOUND)
-
-	ELSE(ASSIMP_QT4_VIEWER)
-		IF (NOT Qt5_FOUND)
-			SET ( ASSIMP_QT_VIEWER_DEPENDENCIES "${ASSIMP_QT_VIEWER_DEPENDENCIES} Qt5")
-		ENDIF (NOT Qt5_FOUND)
-
-	ENDIF(ASSIMP_QT4_VIEWER)
-
-	IF (NOT IL_FOUND)
-		SET ( ASSIMP_QT_VIEWER_DEPENDENCIES "${ASSIMP_QT_VIEWER_DEPENDENCIES} DevIL")
-	ENDIF (NOT IL_FOUND)
+	IF (NOT Qt5_FOUND)
+		SET ( ASSIMP_QT_VIEWER_DEPENDENCIES "${ASSIMP_QT_VIEWER_DEPENDENCIES} Qt5")
+	ENDIF (NOT Qt5_FOUND)
 
 	IF (NOT OPENGL_FOUND)
 		SET ( ASSIMP_QT_VIEWER_DEPENDENCIES "${ASSIMP_QT_VIEWER_DEPENDENCIES} OpengGL")
 	ENDIF (NOT OPENGL_FOUND)
 
 	MESSAGE (WARNING "Build of assimp_qt_viewer is disabled. Unsatisfied dendencies: ${ASSIMP_QT_VIEWER_DEPENDENCIES}")
-ENDIF((Qt4_FOUND OR Qt5Widgets_FOUND) AND IL_FOUND AND OPENGL_FOUND)
+ENDIF( Qt5Widgets_FOUND AND OPENGL_FOUND)
 
 IF(VIEWER_BUILD)
 	INCLUDE_DIRECTORIES(
@@ -63,28 +39,23 @@ IF(VIEWER_BUILD)
 	LINK_DIRECTORIES(${Assimp_BINARY_DIR})
 	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -pedantic -Wall")
 
-	SET(assimp_qt_viewer_SRCS main.cpp loggerview.cpp glview.cpp mainwindow.cpp)
-
-	IF(ASSIMP_QT4_VIEWER)
-		MESSAGE("assimp_qt_viewer use Qt4")
-		ADD_DEFINITIONS( -DASSIMP_QT4_VIEWER )
-		INCLUDE_DIRECTORIES(${QT_INCLUDES})
-		qt4_wrap_ui(UISrcs mainwindow.ui)
-		qt4_wrap_cpp(MOCrcs mainwindow.hpp glview.hpp)
-	ELSE()
-		MESSAGE("assimp_qt_viewer use Qt5")
-		INCLUDE_DIRECTORIES(${Qt5Widgets_INCLUDES})
-		qt5_wrap_ui(UISrcs mainwindow.ui)
-		qt5_wrap_cpp(MOCrcs mainwindow.hpp glview.hpp)
-	ENDIF()
+	SET(assimp_qt_viewer_SRCS 
+        main.cpp 
+        loggerview.hpp
+        loggerview.cpp 
+        glview.hpp
+        glview.cpp 
+        mainwindow.hpp
+        mainwindow.cpp
+    )
+
+	MESSAGE("assimp_qt_viewer use Qt5")
+	INCLUDE_DIRECTORIES(${Qt5Widgets_INCLUDES})
+	qt5_wrap_ui(UISrcs mainwindow.ui)
+	qt5_wrap_cpp(MOCrcs mainwindow.hpp glview.hpp)
 
 	add_executable(${PROJECT_NAME} ${assimp_qt_viewer_SRCS} ${UISrcs} ${MOCrcs})
-
-	IF(ASSIMP_QT4_VIEWER)
-		target_link_libraries(${PROJECT_NAME} ${QT_LIBRARIES} ${QT_QTCORE_LIBRARY} ${QT_QTGUI_LIBRARY} ${QT_QTOPENGL_LIBRARY} ${IL_LIBRARIES} ${OPENGL_LIBRARIES} assimp)
-	ELSE()
-		target_link_libraries(${PROJECT_NAME} Qt5::Gui Qt5::Widgets Qt5::OpenGL ${IL_LIBRARIES} ${OPENGL_LIBRARIES} assimp)
-	ENDIF()
+	target_link_libraries(${PROJECT_NAME} Qt5::Gui Qt5::Widgets Qt5::OpenGL ${IL_LIBRARIES} ${OPENGL_LIBRARIES} assimp)
 
 	IF(WIN32) # Check if we are on Windows
 		IF(MSVC) # Check if we are using the Visual Studio compiler

tools/assimp_qt_viewer/glview.cpp

@@ -1,8 +1,45 @@
-/// \file   glview.cpp
-/// \brief  OpenGL visualisation. Implementation file.
-/// \author [email protected]
-/// \date   2016
-
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, 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.
+---------------------------------------------------------------------------
+*/
 #include "glview.hpp"
 
 // Header files, Qt.
@@ -16,40 +53,30 @@
 #endif
 
 // Header files, DevIL.
-#include <il.h>
 
 // Header files, Assimp.
 #include <assimp/DefaultLogger.hpp>
 
-#ifndef __unused
-	#define __unused	__attribute__((unused))
-#endif // __unused
-
-/**********************************/
-/********** SHelper_Mesh **********/
-/**********************************/
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"
 
 CGLView::SHelper_Mesh::SHelper_Mesh(const size_t pQuantity_Point, const size_t pQuantity_Line, const size_t pQuantity_Triangle, const SBBox& pBBox)
-	: Quantity_Point(pQuantity_Point), Quantity_Line(pQuantity_Line), Quantity_Triangle(pQuantity_Triangle), BBox(pBBox)
-{
+: Quantity_Point(pQuantity_Point)
+, Quantity_Line(pQuantity_Line)
+, Quantity_Triangle(pQuantity_Triangle)
+, BBox(pBBox) {
 	Index_Point = pQuantity_Point ? new GLuint[pQuantity_Point * 1] : nullptr;
 	Index_Line = pQuantity_Line ? new GLuint[pQuantity_Line * 2] : nullptr;
 	Index_Triangle = pQuantity_Triangle ? new GLuint[pQuantity_Triangle * 3] : nullptr;
 }
 
-CGLView::SHelper_Mesh::~SHelper_Mesh()
-{
-	if(Index_Point != nullptr) delete [] Index_Point;
-	if(Index_Line != nullptr) delete [] Index_Line;
-	if(Index_Triangle != nullptr) delete [] Index_Triangle;
+CGLView::SHelper_Mesh::~SHelper_Mesh() {
+	delete [] Index_Point;
+	delete [] Index_Line;
+	delete [] Index_Triangle;
 }
 
-/**********************************/
-/********** SHelper_Mesh **********/
-/**********************************/
-
-void CGLView::SHelper_Camera::SetDefault()
-{
+void CGLView::SHelper_Camera::SetDefault() {
 	Position.Set(0, 0, 0);
 	Target.Set(0, 0, -1);
 	Rotation_AroundCamera = aiMatrix4x4();
@@ -57,39 +84,21 @@ void CGLView::SHelper_Camera::SetDefault()
 	Translation_ToScene.Set(0, 0, 2);
 }
 
-/**********************************/
-/************ CGLView *************/
-/**********************************/
-
-#if !ASSIMP_QT4_VIEWER
-#	define ConditionalContextControl_Begin \
-		bool ContextEnabledHere; \
-		\
-		if(mGLContext_Current) \
-		{ \
-			ContextEnabledHere = false; \
-		} \
-		else \
-		{ \
-			makeCurrent(); \
-			mGLContext_Current = true; \
-			ContextEnabledHere = true; \
-		} \
-		\
-		do {} while(false)
-
-#	define ConditionalContextControl_End \
-		if(ContextEnabledHere) \
-		{ \
-			doneCurrent(); \
-			mGLContext_Current = false; \
-		} \
-		\
-		do {} while(false)
-#endif // ASSIMP_QT4_VIEWER
-
-void CGLView::Material_Apply(const aiMaterial* pMaterial)
-{
+static void set_float4(float f[4], float a, float b, float c, float d) {
+    f[0] = a;
+    f[1] = b;
+    f[2] = c;
+    f[3] = d;
+}
+
+static void color4_to_float4(const aiColor4D *c, float f[4]) {
+    f[0] = c->r;
+    f[1] = c->g;
+    f[2] = c->b;
+    f[3] = c->a;
+}
+
+void CGLView::Material_Apply(const aiMaterial* pMaterial) {
     GLfloat tcol[4];
     aiColor4D taicol;
     unsigned int max;
@@ -97,15 +106,12 @@ void CGLView::Material_Apply(const aiMaterial* pMaterial)
     int texture_index = 0;
     aiString texture_path;
 
-    auto set_float4 = [](float f[4], float a, float b, float c, float d) { f[0] = a, f[1] = b, f[2] = c, f[3] = d; };
-    auto color4_to_float4 = [](const aiColor4D *c, float f[4]) { f[0] = c->r, f[1] = c->g, f[2] = c->b, f[3] = c->a; };
-
 	///TODO: cache materials
 	// Disable color material because glMaterial is used.
 	glDisable(GL_COLOR_MATERIAL);///TODO: cache
-	// Set texture. If assigned.
-	if(AI_SUCCESS == pMaterial->GetTexture(aiTextureType_DIFFUSE, texture_index, &texture_path))
-	{
+	
+                                 // Set texture. If assigned.
+	if(AI_SUCCESS == pMaterial->GetTexture(aiTextureType_DIFFUSE, texture_index, &texture_path)) {
 		//bind texture
 		unsigned int texture_ID = mTexture_IDMap.value(texture_path.data, 0);
 
@@ -116,20 +122,27 @@ void CGLView::Material_Apply(const aiMaterial* pMaterial)
 	//
 	// Diffuse
 	set_float4(tcol, 0.8f, 0.8f, 0.8f, 1.0f);
-	if(AI_SUCCESS == aiGetMaterialColor(pMaterial, AI_MATKEY_COLOR_DIFFUSE, &taicol)) color4_to_float4(&taicol, tcol);
+    if ( AI_SUCCESS == aiGetMaterialColor( pMaterial, AI_MATKEY_COLOR_DIFFUSE, &taicol )) {
+        color4_to_float4( &taicol, tcol );
+    }
 
 	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, tcol);
-	// Specular
+	
+    // Specular
 	set_float4(tcol, 0.0f, 0.0f, 0.0f, 1.0f);
-	if(AI_SUCCESS == aiGetMaterialColor(pMaterial, AI_MATKEY_COLOR_SPECULAR, &taicol)) color4_to_float4(&taicol, tcol);
+    if ( AI_SUCCESS == aiGetMaterialColor( pMaterial, AI_MATKEY_COLOR_SPECULAR, &taicol )) {
+        color4_to_float4( &taicol, tcol );
+    }
 
 	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, tcol);
 	// Ambient
 	set_float4(tcol, 0.2f, 0.2f, 0.2f, 1.0f);
-	if(AI_SUCCESS == aiGetMaterialColor(pMaterial, AI_MATKEY_COLOR_AMBIENT, &taicol)) color4_to_float4(&taicol, tcol);
-
+    if ( AI_SUCCESS == aiGetMaterialColor( pMaterial, AI_MATKEY_COLOR_AMBIENT, &taicol )) {
+        color4_to_float4( &taicol, tcol );
+    }
 	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, tcol);
-	// Emission
+	
+    // Emission
 	set_float4(tcol, 0.0f, 0.0f, 0.0f, 1.0f);
 	if(AI_SUCCESS == aiGetMaterialColor(pMaterial, AI_MATKEY_COLOR_EMISSIVE, &taicol)) color4_to_float4(&taicol, tcol);
 
@@ -142,12 +155,9 @@ void CGLView::Material_Apply(const aiMaterial* pMaterial)
 	// Shininess strength
 	max = 1;
 	ret2 = aiGetMaterialFloatArray(pMaterial, AI_MATKEY_SHININESS_STRENGTH, &strength, &max);
-	if((ret1 == AI_SUCCESS) && (ret2 == AI_SUCCESS))
-	{
+	if((ret1 == AI_SUCCESS) && (ret2 == AI_SUCCESS)) {
 		glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess * strength);///TODO: cache
-	}
-	else
-	{
+	} else {
 		glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0f);///TODO: cache
 		set_float4(tcol, 0.0f, 0.0f, 0.0f, 0.0f);
 		glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, tcol);
@@ -199,38 +209,26 @@ void CGLView::Matrix_NodeToRoot(const aiNode* pNode, aiMatrix4x4& pOutMatrix)
     }
 }
 
-void CGLView::ImportTextures(const QString& pScenePath)
-{
+void CGLView::ImportTextures(const QString& scenePath) {
     auto LoadTexture = [&](const QString& pFileName) -> bool ///TODO: IME texture mode, operation.
     {
-        ILboolean success;
         GLuint id_ogl_texture;// OpenGL texture ID.
 
 	    if(!pFileName.startsWith(AI_EMBEDDED_TEXNAME_PREFIX))
 	    {
-		    ILuint id_image;// DevIL image ID.
-		    QString basepath = pScenePath.left(pScenePath.lastIndexOf('/') + 1);// path with '/' at the end.
+		    QString basepath = scenePath.left(scenePath.lastIndexOf('/') + 1);// path with '/' at the end.
 		    QString fileloc = (basepath + pFileName);
 
 		    fileloc.replace('\\', "/");
-		    ilGenImages(1, &id_image);// Generate DevIL image ID.
-		    ilBindImage(id_image);
-		    success = ilLoadImage(fileloc.toLocal8Bit());
-		    if(!success)
-		    {
+            int x, y, n;
+            unsigned char *data = stbi_load(fileloc.toLocal8Bit(), &x, &y, &n, STBI_rgb_alpha );
+            if ( nullptr == data ) {
 			    LogError(QString("Couldn't load Image: %1").arg(fileloc));
 
 			    return false;
 		    }
 
 		    // Convert every colour component into unsigned byte. If your image contains alpha channel you can replace IL_RGB with IL_RGBA.
-		    success = ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE);
-		    if(!success)
-		    {
-			    LogError("Couldn't convert image.");
-
-			    return false;
-		    }
 
 		    glGenTextures(1, &id_ogl_texture);// Texture ID generation.
 		    mTexture_IDMap[pFileName] = id_ogl_texture;// save texture ID for filename in map
@@ -238,11 +236,9 @@ void CGLView::ImportTextures(const QString& pScenePath)
 		    // Redefine standard texture values
 		    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);// We will use linear interpolation for magnification filter.
 		    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);// We will use linear interpolation for minifying filter.
-		    glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_BPP), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), 0,
-						    ilGetInteger(IL_IMAGE_FORMAT), GL_UNSIGNED_BYTE, ilGetData());// Texture specification.
+            glTexImage2D(GL_TEXTURE_2D, 0, n, x, y, 0, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, data );// Texture specification.
 
-		    //Cleanup
-		    ilDeleteImages(1, &id_image);// Because we have already copied image data into texture data we can release memory used by image.
+            // Cleanup
 	    }
 	    else
 	    {
@@ -321,27 +317,18 @@ void CGLView::ImportTextures(const QString& pScenePath)
 		return;
 	}
 
-	// Before calling ilInit() version should be checked.
-	if(ilGetInteger(IL_VERSION_NUM) < IL_VERSION)
-	{
-		LogError("Wrong DevIL version.");
-
-		return;
-	}
-
-	ilInit();// Initialization of DevIL.
 	//
 	// Load textures.
 	//
 	// Get textures file names and number of textures.
-	for(size_t idx_material = 0; idx_material < mScene->mNumMaterials; idx_material++)
-	{
+	for(size_t idx_material = 0; idx_material < mScene->mNumMaterials; idx_material++) {
 		int idx_texture = 0;
 		aiString path;
 
-		do
-		{
-			if(mScene->mMaterials[idx_material]->GetTexture(aiTextureType_DIFFUSE, idx_texture, &path) != AI_SUCCESS) break;
+		do {
+            if (mScene->mMaterials[ idx_material ]->GetTexture( aiTextureType_DIFFUSE, idx_texture, &path ) != AI_SUCCESS) {
+                break;
+            }
 
 			LoadTexture(QString(path.C_Str()));
 			idx_texture++;
@@ -349,11 +336,8 @@ void CGLView::ImportTextures(const QString& pScenePath)
 	}// for(size_t idx_material = 0; idx_material < mScene->mNumMaterials; idx_material++)
 
 	// Textures list is empty, exit.
-	if(mTexture_IDMap.size() == 0)
-	{
+	if(mTexture_IDMap.empty()) {
 		LogInfo("No textures for import.");
-
-		return;
 	}
 }
 
@@ -451,32 +435,21 @@ void CGLView::BBox_GetFromVertices(const aiVector3D* pVertices, const size_t pVe
 	}
 }
 
-/********************************************************************/
-/************************ Logging functions *************************/
-/********************************************************************/
-
-void CGLView::LogInfo(const QString& pMessage)
-{
+void CGLView::LogInfo(const QString& pMessage) {
 	Assimp::DefaultLogger::get()->info(pMessage.toStdString());
 }
 
-void CGLView::LogError(const QString& pMessage)
-{
+void CGLView::LogError(const QString& pMessage) {
 	Assimp::DefaultLogger::get()->error(pMessage.toStdString());
 }
 
-/********************************************************************/
-/************************** Draw functions **************************/
-/********************************************************************/
-
-void CGLView::Draw_Node(const aiNode* pNode)
-{
+void CGLView::Draw_Node(const aiNode* pNode) {
     aiMatrix4x4 mat_node = pNode->mTransformation;
 
 	// Apply node transformation matrix.
 	mat_node.Transpose();
 	glPushMatrix();
-#if ASSIMP_DOUBLE_PRECISION
+#ifdef ASSIMP_DOUBLE_PRECISION
 	glMultMatrixd((GLdouble*)mat_node[0]);
 #else
 	glMultMatrixf((GLfloat*)&mat_node);
@@ -518,7 +491,7 @@ void CGLView::Draw_Mesh(const size_t pMesh_Index)
 	{
 		glEnable(GL_COLOR_MATERIAL);///TODO: cache
 		glEnableClientState(GL_COLOR_ARRAY);
-#if ASSIMP_DOUBLE_PRECISION
+#ifdef ASSIMP_DOUBLE_PRECISION
 		glColorPointer(4, GL_DOUBLE, 0, mesh_cur.mColors[0]);
 #else
 		glColorPointer(4, GL_FLOAT, 0, mesh_cur.mColors[0]);
@@ -531,7 +504,7 @@ void CGLView::Draw_Mesh(const size_t pMesh_Index)
 	if(mesh_cur.HasTextureCoords(0))
 	{
 		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-#if ASSIMP_DOUBLE_PRECISION
+#ifdef ASSIMP_DOUBLE_PRECISION
 		glTexCoordPointer(2, GL_DOUBLE, sizeof(aiVector3D), mesh_cur.mTextureCoords[0]);
 #else
 		glTexCoordPointer(2, GL_FLOAT, sizeof(aiVector3D), mesh_cur.mTextureCoords[0]);
@@ -544,7 +517,7 @@ void CGLView::Draw_Mesh(const size_t pMesh_Index)
 	if(mesh_cur.HasNormals())
 	{
 		glEnableClientState(GL_NORMAL_ARRAY);
-#if ASSIMP_DOUBLE_PRECISION
+#ifdef ASSIMP_DOUBLE_PRECISION
 		glNormalPointer(GL_DOUBLE, 0, mesh_cur.mNormals);
 #else
 		glNormalPointer(GL_FLOAT, 0, mesh_cur.mNormals);
@@ -581,16 +554,12 @@ void CGLView::Draw_BBox(const SBBox& pBBox)
 	glBindTexture(GL_TEXTURE_1D, 0);
 	glBindTexture(GL_TEXTURE_2D, 0);
 	glBindTexture(GL_TEXTURE_3D, 0);
-#if ASSIMP_QT4_VIEWER
-	qglColor(QColor(Qt::white));
-#else
 	const QColor c_w(Qt::white);
 
 	glColor3f(c_w.redF(), c_w.greenF(), c_w.blueF());
-#endif // ASSIMP_QT4_VIEWER
 
 	glBegin(GL_LINE_STRIP);
-#	if ASSIMP_DOUBLE_PRECISION
+#	ifdef ASSIMP_DOUBLE_PRECISION
 		glVertex3dv(&vertex[0][0]), glVertex3dv(&vertex[1][0]), glVertex3dv(&vertex[2][0]), glVertex3dv(&vertex[3][0]), glVertex3dv(&vertex[0][0]);// "Minimum" side.
 		glVertex3dv(&vertex[4][0]), glVertex3dv(&vertex[5][0]), glVertex3dv(&vertex[6][0]), glVertex3dv(&vertex[7][0]), glVertex3dv(&vertex[4][0]);// Edge and "maximum" side.
 #	else
@@ -600,7 +569,7 @@ void CGLView::Draw_BBox(const SBBox& pBBox)
 	glEnd();
 
 	glBegin(GL_LINES);
-#	if ASSIMP_DOUBLE_PRECISION
+#	ifdef ASSIMP_DOUBLE_PRECISION
 		glVertex3dv(&vertex[1][0]), glVertex3dv(&vertex[5][0]);
 		glVertex3dv(&vertex[2][0]), glVertex3dv(&vertex[6][0]);
 		glVertex3dv(&vertex[3][0]), glVertex3dv(&vertex[7][0]);
@@ -615,48 +584,28 @@ void CGLView::Draw_BBox(const SBBox& pBBox)
 
 }
 
-void CGLView::Enable_Textures(const bool pEnable)
-{
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_Begin;
-#endif // ASSIMP_QT4_VIEWER
-
-	if(pEnable)
-	{
+void CGLView::Enable_Textures(const bool pEnable) {
+	if(pEnable) {
 		glEnable(GL_TEXTURE_1D);
 		glEnable(GL_TEXTURE_2D);
 		glEnable(GL_TEXTURE_3D);
-	}
-	else
-	{
+	} else {
 		glDisable(GL_TEXTURE_1D);
 		glDisable(GL_TEXTURE_2D);
 		glDisable(GL_TEXTURE_3D);
 	}
-
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_End;
-#endif // ASSIMP_QT4_VIEWER
 }
 
-/********************************************************************/
-/*********************** Override functions ************************/
-/********************************************************************/
-
-void CGLView::initializeGL()
-{
-#if ASSIMP_QT4_VIEWER
-	qglClearColor(Qt::gray);
-#else
+void CGLView::initializeGL() {
 	mGLContext_Current = true;
 	initializeOpenGLFunctions();
 	glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
-#endif // ASSIMP_QT4_VIEWER
 	glShadeModel(GL_SMOOTH);
 
 	glEnable(GL_DEPTH_TEST);
 	glEnable(GL_NORMALIZE);
 	glEnable(GL_TEXTURE_2D);
+    glEnable( GL_MULTISAMPLE );
 
 	glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT);
 	glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
@@ -668,25 +617,14 @@ void CGLView::initializeGL()
 	glCullFace(GL_BACK);
 
 	glFrontFace(GL_CCW);
-
-#if !ASSIMP_QT4_VIEWER
-	mGLContext_Current = false;
-#endif // ASSIMP_QT4_VIEWER
 }
 
-void CGLView::resizeGL(int pWidth, int pHeight)
-{
-#if !ASSIMP_QT4_VIEWER
-	mGLContext_Current = true;
-#endif // ASSIMP_QT4_VIEWER
-	mCamera_Viewport_AspectRatio = (GLdouble)pWidth / pHeight;
-	glViewport(0, 0, pWidth, pHeight);
+void CGLView::resizeGL(int width, int height) {
+	mCamera_Viewport_AspectRatio = (GLdouble)width / height;
+	glViewport(0, 0, width, height);
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
 	gluPerspective(mCamera_FOVY, mCamera_Viewport_AspectRatio, 1.0, 100000.0);///TODO: znear/zfar depend on scene size.
-#if !ASSIMP_QT4_VIEWER
-	mGLContext_Current = false;
-#endif // ASSIMP_QT4_VIEWER
 }
 
 void CGLView::drawCoordSystem() {
@@ -699,19 +637,8 @@ void CGLView::drawCoordSystem() {
     glBindTexture(GL_TEXTURE_3D, 0);
     glEnable(GL_COLOR_MATERIAL);
     glBegin(GL_LINES);
-#if ASSIMP_QT4_VIEWER
-	// X, -X
-    qglColor(QColor(Qt::red)), glVertex3f(0.0, 0.0, 0.0), glVertex3f(100000.0, 0.0, 0.0);
-    qglColor(QColor(Qt::cyan)), glVertex3f(0.0, 0.0, 0.0), glVertex3f(-100000.0, 0.0, 0.0);
-    // Y, -Y
-    qglColor(QColor(Qt::green)), glVertex3f(0.0, 0.0, 0.0), glVertex3f(0.0, 100000.0, 0.0);
-    qglColor(QColor(Qt::magenta)), glVertex3f(0.0, 0.0, 0.0), glVertex3f(0.0, -100000.0, 0.0);
-    // Z, -Z
-    qglColor(QColor(Qt::blue)), glVertex3f(0.0, 0.0, 0.0), glVertex3f(0.0, 0.0, 100000.0);
-    qglColor(QColor(Qt::yellow)), glVertex3f(0.0, 0.0, 0.0), glVertex3f(0.0, 0.0, -100000.0);
-    qglColor(QColor(Qt::white));
-#else
-	// X, -X
+
+    // X, -X
 	glColor3f(1.0f, 0.0f, 0.0f), glVertex3f(0.0, 0.0, 0.0), glVertex3f(100000.0, 0.0, 0.0);
 	glColor3f(0.5f, 0.5f, 1.0f), glVertex3f(0.0, 0.0, 0.0), glVertex3f(-100000.0, 0.0, 0.0);
 	// Y, -Y
@@ -721,19 +648,15 @@ void CGLView::drawCoordSystem() {
 	glColor3f(0.0f, 0.0f, 1.0f), glVertex3f(0.0, 0.0, 0.0), glVertex3f(0.0, 0.0, 100000.0);
 	glColor3f(1.0f, 1.0f, 0.0f), glVertex3f(0.0, 0.0, 0.0), glVertex3f(0.0, 0.0, -100000.0);
 	glColor3f(1.0f, 1.0f, 1.0f);
-#endif // ASSIMP_QT4_VIEWER
-	glEnd();
-	// Restore previous state of lighting.
-	if(mLightingEnabled) glEnable(GL_LIGHTING);
 
+    glEnd();
+	// Restore previous state of lighting.
+    if (mLightingEnabled) {
+        glEnable( GL_LIGHTING );
+    }
 }
 
-void CGLView::paintGL()
-{
-#if !ASSIMP_QT4_VIEWER
-	mGLContext_Current = true;
-#endif // ASSIMP_QT4_VIEWER
-
+void CGLView::paintGL() {
 	QTime time_paintbegin;
 
 	time_paintbegin = QTime::currentTime();
@@ -741,6 +664,7 @@ void CGLView::paintGL()
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 	glMatrixMode(GL_MODELVIEW);
 	glLoadIdentity();
+
 	// Apply current camera transformations.
 #if ASSIMP_DOUBLE_PRECISION
 	glMultMatrixd((GLdouble*)&mHelper_Camera.Rotation_AroundCamera);
@@ -753,58 +677,38 @@ void CGLView::paintGL()
 #endif // ASSIMP_DOUBLE_PRECISION
 
 	// Coordinate system
-	if (mScene_AxesEnabled == true)
-    {
+	if ( mScene_AxesEnabled ) {
         drawCoordSystem();
     }
 
 	glDisable(GL_COLOR_MATERIAL);
-	// Scene
-	if(mScene != nullptr)
-	{
+	
+    // Scene
+	if(mScene != nullptr) {
 		Draw_Node(mScene->mRootNode);
 		// Scene BBox
-		if(mScene_DrawBBox) Draw_BBox(mScene_BBox);
-
+        if (mScene_DrawBBox) {
+            Draw_BBox( mScene_BBox );
+        }
 	}
 
-	emit Paint_Finished((size_t)time_paintbegin.msecsTo(QTime::currentTime()), mHelper_Camera.Translation_ToScene.Length());
-#if !ASSIMP_QT4_VIEWER
-	mGLContext_Current = false;
-#endif // ASSIMP_QT4_VIEWER
+	emit Paint_Finished((size_t) time_paintbegin.msecsTo(QTime::currentTime()), mHelper_Camera.Translation_ToScene.Length());
 }
 
-/********************************************************************/
-/********************** Constructor/Destructor **********************/
-/********************************************************************/
 
-CGLView::CGLView(QWidget *pParent)
-#if ASSIMP_QT4_VIEWER
-	: QGLWidget(QGLFormat(QGL::DoubleBuffer | QGL::DepthBuffer), pParent)
-#else
-	: QOpenGLWidget(pParent), mGLContext_Current(false)
-#endif // ASSIMP_QT4_VIEWER
-{
-	// set initial view
-	mHelper_CameraDefault.SetDefault();
-	Camera_Set(0);
+CGLView::CGLView( QWidget *pParent )
+: QOpenGLWidget( pParent )
+, mGLContext_Current( false ) {
+    // set initial view
+    mHelper_CameraDefault.SetDefault();
+    Camera_Set( 0 );
 }
 
-CGLView::~CGLView()
-{
+CGLView::~CGLView() {
 	FreeScene();
 }
 
-/********************************************************************/
-/********************* Scene control functions **********************/
-/********************************************************************/
-
-void CGLView::FreeScene()
-{
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_Begin;
-#endif // ASSIMP_QT4_VIEWER
-
+void CGLView::FreeScene() {
 	// Set scene to null and after that \ref paintGL will not try to render it.
 	mScene = nullptr;
 	// Clean helper objects.
@@ -834,21 +738,14 @@ void CGLView::FreeScene()
 		mTexture_IDMap.clear();
 		delete [] id_tex;
 	}
-
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_End;
-#endif // ASSIMP_QT4_VIEWER
 }
 
-void CGLView::SetScene(const aiScene *pScene, const QString& pScenePath)
-{
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_Begin;
-#endif // ASSIMP_QT4_VIEWER
-
-	FreeScene();// Clear old data
+void CGLView::SetScene(const aiScene *pScene, const QString& pScenePath) {
+    FreeScene();// Clear old data
 	// Why checking here, not at begin of function. Because old scene may not exist at know. So, need cleanup.
-	if(pScene == nullptr) return;
+    if (pScene == nullptr) {
+        return;
+    }
 
 	mScene = pScene;// Copy pointer of new scene.
 
@@ -874,7 +771,7 @@ void CGLView::SetScene(const aiScene *pScene, const QString& pScenePath)
 
 			BBox_GetFromVertices(mesh_cur.mVertices, mesh_cur.mNumVertices, mesh_bbox);
 			//
-			// Create vertices indices arrays splited by primitive type.
+			// Create vertices indices arrays splitted by primitive type.
 			//
 			size_t indcnt_p = 0;// points quantity
 			size_t indcnt_l = 0;// lines quantity
@@ -1039,7 +936,10 @@ void CGLView::SetScene(const aiScene *pScene, const QString& pScenePath)
 			}// switch(light_cur.mType)
 
 			// Add light source
-			if(name.isEmpty()) name += QString("%1").arg(idx_light);// Use index if name is empty.
+            // Use index if name is empty.
+            if (name.isEmpty()) {
+                name += QString( "%1" ).arg( idx_light );
+            }
 
 			Lighting_EditSource(idx_light, lp);
 			emit SceneObject_LightSource(name);// Light source will be enabled in signal handler.
@@ -1072,66 +972,48 @@ void CGLView::SetScene(const aiScene *pScene, const QString& pScenePath)
 			emit SceneObject_Camera(mScene->mCameras[idx_cam]->mName.C_Str());
 		}
 	}// if(!mScene->HasCameras()) else
-
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_End;
-#endif // ASSIMP_QT4_VIEWER
 }
 
-/********************************************************************/
-/******************** Lighting control functions ********************/
-/********************************************************************/
-
-void CGLView::Lighting_Enable()
-{
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_Begin;
-#endif // ASSIMP_QT4_VIEWER
-
+void CGLView::Lighting_Enable() {
 	mLightingEnabled = true;
 	glEnable(GL_LIGHTING);
-
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_End;
-#endif // ASSIMP_QT4_VIEWER
 }
 
-void CGLView::Lighting_Disable()
-{
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_Begin;
-#endif // ASSIMP_QT4_VIEWER
-
-	glDisable(GL_LIGHTING);
+void CGLView::Lighting_Disable() {
+    glDisable( GL_LIGHTING );
 	mLightingEnabled = false;
-
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_End;
-#endif // ASSIMP_QT4_VIEWER
 }
 
 void CGLView::Lighting_EditSource(const size_t pLightNumber, const SLightParameters& pLightParameters)
 {
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_Begin;
-#endif // ASSIMP_QT4_VIEWER
+    const size_t light_num = GL_LIGHT0 + pLightNumber;
 
-const size_t light_num = GL_LIGHT0 + pLightNumber;
-
-GLfloat farr[4];
+    GLfloat farr[4];
 
 	if(pLightNumber >= GL_MAX_LIGHTS) return;///TODO: return value;
 
 	// Ambient color
-	farr[0] = pLightParameters.Ambient.r, farr[1] = pLightParameters.Ambient.g; farr[2] = pLightParameters.Ambient.b; farr[3] = pLightParameters.Ambient.a;
+    farr[0] = pLightParameters.Ambient.r;
+    farr[1] = pLightParameters.Ambient.g;
+    farr[2] = pLightParameters.Ambient.b;
+    farr[3] = pLightParameters.Ambient.a;
 	glLightfv(light_num, GL_AMBIENT, farr);
-	// Diffuse color
-	farr[0] = pLightParameters.Diffuse.r, farr[1] = pLightParameters.Diffuse.g; farr[2] = pLightParameters.Diffuse.b; farr[3] = pLightParameters.Diffuse.a;
+
+    // Diffuse color
+    farr[0] = pLightParameters.Diffuse.r;
+    farr[1] = pLightParameters.Diffuse.g;
+    farr[2] = pLightParameters.Diffuse.b;
+    farr[3] = pLightParameters.Diffuse.a;
 	glLightfv(light_num, GL_DIFFUSE, farr);
-	// Specular color
-	farr[0] = pLightParameters.Specular.r, farr[1] = pLightParameters.Specular.g; farr[2] = pLightParameters.Specular.b; farr[3] = pLightParameters.Specular.a;
+
+    // Specular color
+    farr[0] = pLightParameters.Specular.r;
+    farr[1] = pLightParameters.Specular.g;
+    farr[2] = pLightParameters.Specular.b;
+    farr[3] = pLightParameters.Specular.a;
 	glLightfv(light_num, GL_SPECULAR, farr);
-	// Other parameters
+
+    // Other parameters
 	switch(pLightParameters.Type)
 	{
 		case aiLightSource_DIRECTIONAL:
@@ -1176,46 +1058,21 @@ GLfloat farr[4];
 			glLightf(light_num, GL_SPOT_CUTOFF, 180.0);
 			break;
 	}// switch(pLightParameters.Type)
-
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_End;
-#endif // ASSIMP_QT4_VIEWER
 }
 
-void CGLView::Lighting_EnableSource(const size_t pLightNumber)
-{
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_Begin;
-#endif // ASSIMP_QT4_VIEWER
-
+void CGLView::Lighting_EnableSource(const size_t pLightNumber) {
 	if(pLightNumber >= GL_MAX_LIGHTS) return;///TODO: return value;
 
 	glEnable(GL_LIGHT0 + pLightNumber);
-
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_End;
-#endif // ASSIMP_QT4_VIEWER
 }
 
 void CGLView::Lighting_DisableSource(const size_t pLightNumber)
 {
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_Begin;
-#endif // ASSIMP_QT4_VIEWER
-
 	if(pLightNumber >= GL_MAX_LIGHTS) return;///TODO: return value;
 
 	glDisable(GL_LIGHT0 + pLightNumber);
-
-#if !ASSIMP_QT4_VIEWER
-	ConditionalContextControl_End;
-#endif // ASSIMP_QT4_VIEWER
 }
 
-/********************************************************************/
-/******************** Cameras control functions *********************/
-/********************************************************************/
-
 void CGLView::Camera_Set(const size_t pCameraNumber)
 {
     SHelper_Camera& hcam = mHelper_Camera;// reference with short name for conveniance.
@@ -1263,7 +1120,7 @@ void CGLView::Camera_Set(const size_t pCameraNumber)
 
 void CGLView::Camera_RotateScene(const GLfloat pAngle_X, const GLfloat pAngle_Y, const GLfloat pAngle_Z, const aiMatrix4x4* pMatrix_Rotation_Initial) {
     auto deg2rad = [](const GLfloat pDegree) -> GLfloat { 
-        return pDegree * AI_MATH_PI / 180.0;
+        return pDegree * AI_MATH_PI / 180.0f;
     };
 
 	aiMatrix4x4 mat_rot;

tools/assimp_qt_viewer/glview.hpp

@@ -1,7 +1,45 @@
-/// \file   glview.hpp
-/// \brief  OpenGL visualisation.
-/// \author [email protected]
-/// \date   2016
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, 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.
+---------------------------------------------------------------------------
+*/
 
 #pragma once
 

tools/assimp_qt_viewer/loggerview.cpp

@@ -1,19 +1,64 @@
-/// \file   loggerview.cpp
-/// \brief  Stream for Assimp logging subsystem.
-/// \author [email protected]
-/// \date   2016
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
 
+Copyright (c) 2006-2018, 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.
+---------------------------------------------------------------------------
+*/
 #include "loggerview.hpp"
 
 // Header files, Qt.
 #include <QTime>
+#include <QTextBrowser>
 
 CLoggerView::CLoggerView(QTextBrowser* pOutputWidget)
-	: mOutputWidget(pOutputWidget)
-{
+: mOutputWidget(pOutputWidget) {
+    // empty
 }
 
-void CLoggerView::write(const char *pMessage)
-{
+CLoggerView::~CLoggerView() {
+    mOutputWidget = nullptr;
+}
+
+void CLoggerView::write(const char *pMessage) {
+    if (nullptr == mOutputWidget) {
+        return;
+    }
+
 	mOutputWidget->insertPlainText(QString("[%1] %2").arg(QTime::currentTime().toString()).arg(pMessage));
 }

tools/assimp_qt_viewer/loggerview.hpp

@@ -1,33 +1,67 @@
-/// \file   loggerview.hpp
-/// \brief  Stream for Assimp logging subsystem.
-/// \author [email protected]
-/// \date   2016
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
 
-#pragma once
+Copyright (c) 2006-2018, 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.
 
-// Header files, Qt.
-#include <QTextBrowser>
+* 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.
+---------------------------------------------------------------------------
+*/
+#pragma once
 
 // Header files, Assimp.
 #include <assimp/DefaultLogger.hpp>
 
-/// \class CLoggerView
-/// GUI-stream for Assimp logging subsytem. Get data for logging and write it to output widget.
-class CLoggerView final : public Assimp::LogStream
-{
-private:
-
-	QTextBrowser* mOutputWidget;///< Widget for displaying messages.
+class QTextBrowser;
 
+/// @class  CLoggerView
+/// @brief  GUI-stream for Assimp logging sub-sytem. Get data for logging and write it to output widget.
+class CLoggerView final : public ::Assimp::LogStream {
 public:
+	/// @brief  The class constructor.
+	/// @param [in] pOutputWidget - pointer to output widget.
+	explicit CLoggerView( QTextBrowser* pOutputWidget );
 
-	/// \fn explicit CLoggerView(QTextBrowser* pOutputWidget)
-	/// Constructor.
-	/// \param [in] pOutputWidget - pointer to output widget.
-	explicit CLoggerView(QTextBrowser* pOutputWidget);
+    /// @brief  The class destructor.
+    virtual ~CLoggerView();
 
-	/// \fn virtual void write(const char *pMessage)
 	/// Write message to output widget. Used by Assimp.
 	/// \param [in] pMessage - message for displaying.
 	virtual void write(const char *pMessage);
+
+private:
+    QTextBrowser * mOutputWidget; ///< Widget for displaying messages.
 };

tools/assimp_qt_viewer/main.cpp

@@ -1,7 +1,46 @@
-/// \file   main.cpp
-/// \brief  Start-up file which contain function "main".
-/// \author [email protected]
-/// \date   2016
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, 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.
+---------------------------------------------------------------------------
+*/
+
 // Thanks to acorn89 for support.
 
 // Header files, project.
@@ -11,9 +50,9 @@
 #include <QApplication>
 
 int main(int argc, char *argv[]) {
-    QApplication a(argc, argv);
-    MainWindow w;
-    w.show();
+    QApplication app(argc, argv);
+    MainWindow win;
+    win.show();
 
-    return a.exec();
+    return app.exec();
 }

tools/assimp_qt_viewer/mainwindow.cpp

@@ -1,7 +1,45 @@
-/// \file   mainwindow.hpp
-/// \brief  Main window and algorhytms.
-/// \author [email protected]
-/// \date   2016
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, 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.
+---------------------------------------------------------------------------
+*/
 
 #include "mainwindow.hpp"
 #include "ui_mainwindow.h"
@@ -14,22 +52,13 @@
 	#define __unused	__attribute__((unused))
 #endif // __unused
 
-/**********************************/
-/************ Functions ***********/
-/**********************************/
-
-/********************************************************************/
-/********************* Import/Export functions **********************/
-/********************************************************************/
-
-void MainWindow::ImportFile(const QString &pFileName)
-{
 using namespace Assimp;
 
-QTime time_begin = QTime::currentTime();
 
-	if(mScene != nullptr)
-	{
+void MainWindow::ImportFile(const QString &pFileName) {
+    QTime time_begin = QTime::currentTime();
+
+	if ( mScene != nullptr ) {
 		mImporter.FreeScene();
 		mGLView->FreeScene();
 	}
@@ -37,8 +66,7 @@ QTime time_begin = QTime::currentTime();
 	// Try to import scene.
 	mScene = mImporter.ReadFile(pFileName.toStdString(), aiProcess_Triangulate | aiProcess_GenNormals | aiProcess_ValidateDataStructure | \
 															aiProcess_GenUVCoords | aiProcess_TransformUVCoords | aiProcess_FlipUVs);
-	if(mScene != nullptr)
-	{
+	if ( mScene != nullptr ) {
 		ui->lblLoadTime->setText(QString::number(time_begin.secsTo(QTime::currentTime())));
 		LogInfo("Import done: " + pFileName);
 		// Prepare widgets for new scene.
@@ -60,8 +88,7 @@ QTime time_begin = QTime::currentTime();
 		size_t qty_face = 0;
 		size_t qty_vert = 0;
 
-		for(size_t idx_mesh = 0; idx_mesh < mScene->mNumMeshes; idx_mesh++)
-		{
+		for(size_t idx_mesh = 0; idx_mesh < mScene->mNumMeshes; idx_mesh++) {
 			qty_face += mScene->mMeshes[idx_mesh]->mNumFaces;
 			qty_vert += mScene->mMeshes[idx_mesh]->mNumVertices;
 		}
@@ -241,7 +268,6 @@ MainWindow::MainWindow(QWidget *parent)
 	: QMainWindow(parent), ui(new Ui::MainWindow),
 		mScene(nullptr)
 {
-using namespace Assimp;
 
 	// other variables
 	mMouse_Transformation.Position_Pressed_Valid = false;

tools/assimp_qt_viewer/mainwindow.hpp

@@ -1,7 +1,45 @@
-/// \file   mainwindow.hpp
-/// \brief  Main window and algorhytms.
-/// \author [email protected]
-/// \date   2016
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, 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.
+---------------------------------------------------------------------------
+*/
 
 #pragma once
 
@@ -20,125 +58,64 @@
 #include <assimp/Importer.hpp>
 #include <assimp/scene.h>
 
-namespace Ui { class MainWindow; }
+namespace Ui { 
+    class MainWindow; 
+}
 
 /// \class MainWindow
-/// Main window and algorhytms.
-class MainWindow : public QMainWindow
-{
-	Q_OBJECT
-
-	/**********************************/
-	/************ Variables ***********/
-	/**********************************/
+/// Main window and algorithms.
+class MainWindow : public QMainWindow {
+    Q_OBJECT
 
-private:
+    struct SMouse_Transformation;
 
-	Ui::MainWindow *ui;
-
-	CGLView* mGLView;///< Pointer to OpenGL render.
-	CLoggerView* mLoggerView;///< Pointer to logging object.
-	Assimp::Importer mImporter;///< Assimp importer.
-	const aiScene* mScene;///< Pointer to loaded scene (\ref aiScene).
-
-	/// \struct SMouse_Transformation
-	/// Holds data about transformation of the scene/camera when mouse us used.
-	struct SMouse_Transformation
-	{
-		bool Position_Pressed_Valid;///< Mouse button pressed on GLView.
-		QPoint Position_Pressed_LMB;///< Position where was pressed left mouse button.
-		QPoint Position_Pressed_RMB;///< Position where was pressed right mouse button.
-		aiMatrix4x4 Rotation_AroundCamera;///< Rotation matrix which set rotation angles of the scene around camera.
-		aiMatrix4x4 Rotation_Scene;///< Rotation matrix which set rotation angles of the scene around own center.
-	} mMouse_Transformation;
-
-	/**********************************/
-	/************ Functions ***********/
-	/**********************************/
-
-	/********************************************************************/
-	/********************* Import/Export functions **********************/
-	/********************************************************************/
-
-	/// \fn void ImportFile(const QString& pFileName)
-	/// Import scene from file.
+public:
+    /// @brief  The class constructor.
+    /// \param [in] pParent - pointer to parent widget.
+    explicit MainWindow( QWidget* pParent = 0 );
+
+    /// @brief  The class destructor.
+    ~MainWindow();
+    
+    /// Import scene from file.
 	/// \param [in] pFileName - path and name of the file.
 	void ImportFile(const QString& pFileName);
 
-
-	/// \fn void ResetSceneInfos()
 	/// Reset informations about the scene
 	void ResetSceneInfos();
 
-	/********************************************************************/
-	/************************ Logging functions *************************/
-	/********************************************************************/
-
-	/// \fn void LogInfo(const QString& pMessage)
 	/// Add message with severity "Warning" to log.
 	void LogInfo(const QString& pMessage);
 
-	/// \fn void LogError(const QString& pMessage)
 	/// Add message with severity "Error" to log.
 	void LogError(const QString& pMessage);
 
-	/********************************************************************/
-	/*********************** Override functions ************************/
-	/********************************************************************/
-
 protected:
-
-	/// \fn void mousePressEvent(QMouseEvent* pEvent) override
 	/// Override function which handles mouse event "button pressed".
 	/// \param [in] pEvent - pointer to event data.
 	void mousePressEvent(QMouseEvent* pEvent) override;
 
-	/// \fn void mouseReleaseEvent(QMouseEvent *pEvent) override
 	/// Override function which handles mouse event "button released".
 	/// \param [in] pEvent - pointer to event data.
 	void mouseReleaseEvent(QMouseEvent *pEvent) override;
 
-	/// \fn void mouseMoveEvent(QMouseEvent* pEvent) override
 	/// Override function which handles mouse event "move".
 	/// \param [in] pEvent - pointer to event data.
 	void mouseMoveEvent(QMouseEvent* pEvent) override;
 
-	/// \fn void keyPressEvent(QKeyEvent* pEvent) override
 	/// Override function which handles key event "key pressed".
 	/// \param [in] pEvent - pointer to event data.
 	void keyPressEvent(QKeyEvent* pEvent) override;
 
-public:
-
-	/********************************************************************/
-	/********************** Constructor/Destructor **********************/
-	/********************************************************************/
-
-	/// \fn explicit MainWindow(QWidget* pParent = 0)
-	/// \param [in] pParent - pointer to parent widget.
-	explicit MainWindow(QWidget* pParent = 0);
-
-	/// \fn ~MainWindow()
-	/// Destructor.
-	~MainWindow();
-
-	/********************************************************************/
-	/****************************** Slots *******************************/
-	/********************************************************************/
-
 private slots:
-
-	/// \fn void Paint_Finished(const int pPaintTime)
 	/// Show paint/render time and distance between camera and center of the scene.
 	/// \param [in] pPaintTime_ms - paint time in milliseconds.
 	void Paint_Finished(const size_t pPaintTime_ms, const GLfloat pDistance);
 
-	/// \fn void SceneObject_Camera(const QString& pName)
 	/// Add camera name to list.
 	/// \param [in] pName - name of the camera.
 	void SceneObject_Camera(const QString& pName);
 
-	/// \fn void SceneObject_LightSource(const QString& pName)
 	/// Add lighting source name to list.
 	/// \param [in] pName - name of the light source,
 	void SceneObject_LightSource(const QString& pName);
@@ -151,4 +128,21 @@ private slots:
 	void on_cbxBBox_clicked(bool checked);
 	void on_cbxTextures_clicked(bool checked);
 	void on_cbxDrawAxes_clicked(bool checked);
+
+private:
+    Ui::MainWindow *ui;
+    CGLView *mGLView;///< Pointer to OpenGL render.
+    CLoggerView *mLoggerView;///< Pointer to logging object.
+    Assimp::Importer mImporter;///< Assimp importer.
+    const aiScene* mScene;///< Pointer to loaded scene (\ref aiScene).
+
+    /// \struct SMouse_Transformation
+    /// Holds data about transformation of the scene/camera when mouse us used.
+    struct SMouse_Transformation {
+        bool Position_Pressed_Valid;///< Mouse button pressed on GLView.
+        QPoint Position_Pressed_LMB;///< Position where was pressed left mouse button.
+        QPoint Position_Pressed_RMB;///< Position where was pressed right mouse button.
+        aiMatrix4x4 Rotation_AroundCamera;///< Rotation matrix which set rotation angles of the scene around camera.
+        aiMatrix4x4 Rotation_Scene;///< Rotation matrix which set rotation angles of the scene around own center.
+    } mMouse_Transformation;
 };

tools/assimp_qt_viewer/stb_image.h

@@ -0,0 +1,7462 @@
+/* stb_image - v2.19 - public domain image loader - http://nothings.org/stb
+                                  no warranty implied; use at your own risk
+
+   Do this:
+      #define STB_IMAGE_IMPLEMENTATION
+   before you include this file in *one* C or C++ file to create the implementation.
+
+   // i.e. it should look like this:
+   #include ...
+   #include ...
+   #include ...
+   #define STB_IMAGE_IMPLEMENTATION
+   #include "stb_image.h"
+
+   You can #define STBI_ASSERT(x) before the #include to avoid using assert.h.
+   And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free
+
+
+   QUICK NOTES:
+      Primarily of interest to game developers and other people who can
+          avoid problematic images and only need the trivial interface
+
+      JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib)
+      PNG 1/2/4/8/16-bit-per-channel
+
+      TGA (not sure what subset, if a subset)
+      BMP non-1bpp, non-RLE
+      PSD (composited view only, no extra channels, 8/16 bit-per-channel)
+
+      GIF (*comp always reports as 4-channel)
+      HDR (radiance rgbE format)
+      PIC (Softimage PIC)
+      PNM (PPM and PGM binary only)
+
+      Animated GIF still needs a proper API, but here's one way to do it:
+          http://gist.github.com/urraka/685d9a6340b26b830d49
+
+      - decode from memory or through FILE (define STBI_NO_STDIO to remove code)
+      - decode from arbitrary I/O callbacks
+      - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON)
+
+   Full documentation under "DOCUMENTATION" below.
+
+
+LICENSE
+
+  See end of file for license information.
+
+RECENT REVISION HISTORY:
+
+      2.19  (2018-02-11) fix warning
+      2.18  (2018-01-30) fix warnings
+      2.17  (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings
+      2.16  (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes
+      2.15  (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC
+      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
+      2.13  (2016-12-04) experimental 16-bit API, only for PNG so far; fixes
+      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
+      2.11  (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64
+                         RGB-format JPEG; remove white matting in PSD;
+                         allocate large structures on the stack;
+                         correct channel count for PNG & BMP
+      2.10  (2016-01-22) avoid warning introduced in 2.09
+      2.09  (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED
+
+   See end of file for full revision history.
+
+
+ ============================    Contributors    =========================
+
+ Image formats                          Extensions, features
+    Sean Barrett (jpeg, png, bmp)          Jetro Lauha (stbi_info)
+    Nicolas Schulz (hdr, psd)              Martin "SpartanJ" Golini (stbi_info)
+    Jonathan Dummer (tga)                  James "moose2000" Brown (iPhone PNG)
+    Jean-Marc Lienher (gif)                Ben "Disch" Wenger (io callbacks)
+    Tom Seddon (pic)                       Omar Cornut (1/2/4-bit PNG)
+    Thatcher Ulrich (psd)                  Nicolas Guillemot (vertical flip)
+    Ken Miller (pgm, ppm)                  Richard Mitton (16-bit PSD)
+    github:urraka (animated gif)           Junggon Kim (PNM comments)
+    Christopher Forseth (animated gif)     Daniel Gibson (16-bit TGA)
+                                           socks-the-fox (16-bit PNG)
+                                           Jeremy Sawicki (handle all ImageNet JPGs)
+ Optimizations & bugfixes                  Mikhail Morozov (1-bit BMP)
+    Fabian "ryg" Giesen                    Anael Seghezzi (is-16-bit query)
+    Arseny Kapoulkine
+    John-Mark Allen
+
+ Bug & warning fixes
+    Marc LeBlanc            David Woo          Guillaume George   Martins Mozeiko
+    Christpher Lloyd        Jerry Jansson      Joseph Thomson     Phil Jordan
+    Dave Moore              Roy Eltham         Hayaki Saito       Nathan Reed
+    Won Chun                Luke Graham        Johan Duparc       Nick Verigakis
+    the Horde3D community   Thomas Ruf         Ronny Chevalier    github:rlyeh
+    Janez Zemva             John Bartholomew   Michal Cichon      github:romigrou
+    Jonathan Blow           Ken Hamada         Tero Hanninen      github:svdijk
+    Laurent Gomila          Cort Stratton      Sergio Gonzalez    github:snagar
+    Aruelien Pocheville     Thibault Reuille   Cass Everitt       github:Zelex
+    Ryamond Barbiero        Paul Du Bois       Engin Manap        github:grim210
+    Aldo Culquicondor       Philipp Wiesemann  Dale Weiler        github:sammyhw
+    Oriol Ferrer Mesia      Josh Tobin         Matthew Gregan     github:phprus
+    Julian Raschke          Gregory Mullen     Baldur Karlsson    github:poppolopoppo
+    Christian Floisand      Kevin Schmidt                         github:darealshinji
+    Blazej Dariusz Roszkowski                                     github:Michaelangel007
+*/
+
+#ifndef STBI_INCLUDE_STB_IMAGE_H
+#define STBI_INCLUDE_STB_IMAGE_H
+
+// DOCUMENTATION
+//
+// Limitations:
+//    - no 12-bit-per-channel JPEG
+//    - no JPEGs with arithmetic coding
+//    - GIF always returns *comp=4
+//
+// Basic usage (see HDR discussion below for HDR usage):
+//    int x,y,n;
+//    unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
+//    // ... process data if not NULL ...
+//    // ... x = width, y = height, n = # 8-bit components per pixel ...
+//    // ... replace '0' with '1'..'4' to force that many components per pixel
+//    // ... but 'n' will always be the number that it would have been if you said 0
+//    stbi_image_free(data)
+//
+// Standard parameters:
+//    int *x                 -- outputs image width in pixels
+//    int *y                 -- outputs image height in pixels
+//    int *channels_in_file  -- outputs # of image components in image file
+//    int desired_channels   -- if non-zero, # of image components requested in result
+//
+// The return value from an image loader is an 'unsigned char *' which points
+// to the pixel data, or NULL on an allocation failure or if the image is
+// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels,
+// with each pixel consisting of N interleaved 8-bit components; the first
+// pixel pointed to is top-left-most in the image. There is no padding between
+// image scanlines or between pixels, regardless of format. The number of
+// components N is 'desired_channels' if desired_channels is non-zero, or
+// *channels_in_file otherwise. If desired_channels is non-zero,
+// *channels_in_file has the number of components that _would_ have been
+// output otherwise. E.g. if you set desired_channels to 4, you will always
+// get RGBA output, but you can check *channels_in_file to see if it's trivially
+// opaque because e.g. there were only 3 channels in the source image.
+//
+// An output image with N components has the following components interleaved
+// in this order in each pixel:
+//
+//     N=#comp     components
+//       1           grey
+//       2           grey, alpha
+//       3           red, green, blue
+//       4           red, green, blue, alpha
+//
+// If image loading fails for any reason, the return value will be NULL,
+// and *x, *y, *channels_in_file will be unchanged. The function
+// stbi_failure_reason() can be queried for an extremely brief, end-user
+// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS
+// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
+// more user-friendly ones.
+//
+// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
+//
+// ===========================================================================
+//
+// Philosophy
+//
+// stb libraries are designed with the following priorities:
+//
+//    1. easy to use
+//    2. easy to maintain
+//    3. good performance
+//
+// Sometimes I let "good performance" creep up in priority over "easy to maintain",
+// and for best performance I may provide less-easy-to-use APIs that give higher
+// performance, in addition to the easy to use ones. Nevertheless, it's important
+// to keep in mind that from the standpoint of you, a client of this library,
+// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all.
+//
+// Some secondary priorities arise directly from the first two, some of which
+// make more explicit reasons why performance can't be emphasized.
+//
+//    - Portable ("ease of use")
+//    - Small source code footprint ("easy to maintain")
+//    - No dependencies ("ease of use")
+//
+// ===========================================================================
+//
+// I/O callbacks
+//
+// I/O callbacks allow you to read from arbitrary sources, like packaged
+// files or some other source. Data read from callbacks are processed
+// through a small internal buffer (currently 128 bytes) to try to reduce
+// overhead.
+//
+// The three functions you must define are "read" (reads some bytes of data),
+// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
+//
+// ===========================================================================
+//
+// SIMD support
+//
+// The JPEG decoder will try to automatically use SIMD kernels on x86 when
+// supported by the compiler. For ARM Neon support, you must explicitly
+// request it.
+//
+// (The old do-it-yourself SIMD API is no longer supported in the current
+// code.)
+//
+// On x86, SSE2 will automatically be used when available based on a run-time
+// test; if not, the generic C versions are used as a fall-back. On ARM targets,
+// the typical path is to have separate builds for NEON and non-NEON devices
+// (at least this is true for iOS and Android). Therefore, the NEON support is
+// toggled by a build flag: define STBI_NEON to get NEON loops.
+//
+// If for some reason you do not want to use any of SIMD code, or if
+// you have issues compiling it, you can disable it entirely by
+// defining STBI_NO_SIMD.
+//
+// ===========================================================================
+//
+// HDR image support   (disable by defining STBI_NO_HDR)
+//
+// stb_image now supports loading HDR images in general, and currently
+// the Radiance .HDR file format, although the support is provided
+// generically. You can still load any file through the existing interface;
+// if you attempt to load an HDR file, it will be automatically remapped to
+// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
+// both of these constants can be reconfigured through this interface:
+//
+//     stbi_hdr_to_ldr_gamma(2.2f);
+//     stbi_hdr_to_ldr_scale(1.0f);
+//
+// (note, do not use _inverse_ constants; stbi_image will invert them
+// appropriately).
+//
+// Additionally, there is a new, parallel interface for loading files as
+// (linear) floats to preserve the full dynamic range:
+//
+//    float *data = stbi_loadf(filename, &x, &y, &n, 0);
+//
+// If you load LDR images through this interface, those images will
+// be promoted to floating point values, run through the inverse of
+// constants corresponding to the above:
+//
+//     stbi_ldr_to_hdr_scale(1.0f);
+//     stbi_ldr_to_hdr_gamma(2.2f);
+//
+// Finally, given a filename (or an open file or memory block--see header
+// file for details) containing image data, you can query for the "most
+// appropriate" interface to use (that is, whether the image is HDR or
+// not), using:
+//
+//     stbi_is_hdr(char *filename);
+//
+// ===========================================================================
+//
+// iPhone PNG support:
+//
+// By default we convert iphone-formatted PNGs back to RGB, even though
+// they are internally encoded differently. You can disable this conversion
+// by by calling stbi_convert_iphone_png_to_rgb(0), in which case
+// you will always just get the native iphone "format" through (which
+// is BGR stored in RGB).
+//
+// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
+// pixel to remove any premultiplied alpha *only* if the image file explicitly
+// says there's premultiplied data (currently only happens in iPhone images,
+// and only if iPhone convert-to-rgb processing is on).
+//
+// ===========================================================================
+//
+// ADDITIONAL CONFIGURATION
+//
+//  - You can suppress implementation of any of the decoders to reduce
+//    your code footprint by #defining one or more of the following
+//    symbols before creating the implementation.
+//
+//        STBI_NO_JPEG
+//        STBI_NO_PNG
+//        STBI_NO_BMP
+//        STBI_NO_PSD
+//        STBI_NO_TGA
+//        STBI_NO_GIF
+//        STBI_NO_HDR
+//        STBI_NO_PIC
+//        STBI_NO_PNM   (.ppm and .pgm)
+//
+//  - You can request *only* certain decoders and suppress all other ones
+//    (this will be more forward-compatible, as addition of new decoders
+//    doesn't require you to disable them explicitly):
+//
+//        STBI_ONLY_JPEG
+//        STBI_ONLY_PNG
+//        STBI_ONLY_BMP
+//        STBI_ONLY_PSD
+//        STBI_ONLY_TGA
+//        STBI_ONLY_GIF
+//        STBI_ONLY_HDR
+//        STBI_ONLY_PIC
+//        STBI_ONLY_PNM   (.ppm and .pgm)
+//
+//   - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still
+//     want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB
+//
+
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif // STBI_NO_STDIO
+
+#define STBI_VERSION 1
+
+enum
+{
+   STBI_default = 0, // only used for desired_channels
+
+   STBI_grey       = 1,
+   STBI_grey_alpha = 2,
+   STBI_rgb        = 3,
+   STBI_rgb_alpha  = 4
+};
+
+typedef unsigned char stbi_uc;
+typedef unsigned short stbi_us;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef STB_IMAGE_STATIC
+#define STBIDEF static
+#else
+#define STBIDEF extern
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PRIMARY API - works on images of any type
+//
+
+//
+// load image by filename, open file, or memory buffer
+//
+
+typedef struct
+{
+   int      (*read)  (void *user,char *data,int size);   // fill 'data' with 'size' bytes.  return number of bytes actually read
+   void     (*skip)  (void *user,int n);                 // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
+   int      (*eof)   (void *user);                       // returns nonzero if we are at end of file/data
+} stbi_io_callbacks;
+
+////////////////////////////////////
+//
+// 8-bits-per-channel interface
+//
+
+STBIDEF stbi_uc *stbi_load_from_memory   (stbi_uc           const *buffer, int len   , int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk  , void *user, int *x, int *y, int *channels_in_file, int desired_channels);
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
+#endif
+
+
+#ifndef STBI_NO_STDIO
+STBIDEF stbi_uc *stbi_load            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_uc *stbi_load_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+// for stbi_load_from_file, file pointer is left pointing immediately after image
+#endif
+
+////////////////////////////////////
+//
+// 16-bits-per-channel interface
+//
+
+STBIDEF stbi_us *stbi_load_16_from_memory   (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);
+
+#ifndef STBI_NO_STDIO
+STBIDEF stbi_us *stbi_load_16          (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+#endif
+
+////////////////////////////////////
+//
+// float-per-channel interface
+//
+#ifndef STBI_NO_LINEAR
+   STBIDEF float *stbi_loadf_from_memory     (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
+   STBIDEF float *stbi_loadf_from_callbacks  (stbi_io_callbacks const *clbk, void *user, int *x, int *y,  int *channels_in_file, int desired_channels);
+
+   #ifndef STBI_NO_STDIO
+   STBIDEF float *stbi_loadf            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+   STBIDEF float *stbi_loadf_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+   #endif
+#endif
+
+#ifndef STBI_NO_HDR
+   STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma);
+   STBIDEF void   stbi_hdr_to_ldr_scale(float scale);
+#endif // STBI_NO_HDR
+
+#ifndef STBI_NO_LINEAR
+   STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma);
+   STBIDEF void   stbi_ldr_to_hdr_scale(float scale);
+#endif // STBI_NO_LINEAR
+
+// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR
+STBIDEF int    stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+STBIDEF int    stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
+#ifndef STBI_NO_STDIO
+STBIDEF int      stbi_is_hdr          (char const *filename);
+STBIDEF int      stbi_is_hdr_from_file(FILE *f);
+#endif // STBI_NO_STDIO
+
+
+// get a VERY brief reason for failure
+// NOT THREADSAFE
+STBIDEF const char *stbi_failure_reason  (void);
+
+// free the loaded image -- this is just free()
+STBIDEF void     stbi_image_free      (void *retval_from_stbi_load);
+
+// get image dimensions & components without fully decoding
+STBIDEF int      stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
+STBIDEF int      stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
+STBIDEF int      stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len);
+STBIDEF int      stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+
+#ifndef STBI_NO_STDIO
+STBIDEF int      stbi_info               (char const *filename,     int *x, int *y, int *comp);
+STBIDEF int      stbi_info_from_file     (FILE *f,                  int *x, int *y, int *comp);
+STBIDEF int      stbi_is_16_bit          (char const *filename);
+STBIDEF int      stbi_is_16_bit_from_file(FILE *f);
+#endif
+
+
+
+// for image formats that explicitly notate that they have premultiplied alpha,
+// we just return the colors as stored in the file. set this flag to force
+// unpremultiplication. results are undefined if the unpremultiply overflow.
+STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
+
+// indicate whether we should process iphone images back to canonical format,
+// or just pass them through "as-is"
+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
+
+// flip the image vertically, so the first pixel in the output array is the bottom left
+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip);
+
+// ZLIB client - used by PNG, available for other purposes
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);
+STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
+STBIDEF int   stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
+STBIDEF int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+//
+//
+////   end header file   /////////////////////////////////////////////////////
+#endif // STBI_INCLUDE_STB_IMAGE_H
+
+#ifdef STB_IMAGE_IMPLEMENTATION
+
+#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \
+  || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \
+  || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \
+  || defined(STBI_ONLY_ZLIB)
+   #ifndef STBI_ONLY_JPEG
+   #define STBI_NO_JPEG
+   #endif
+   #ifndef STBI_ONLY_PNG
+   #define STBI_NO_PNG
+   #endif
+   #ifndef STBI_ONLY_BMP
+   #define STBI_NO_BMP
+   #endif
+   #ifndef STBI_ONLY_PSD
+   #define STBI_NO_PSD
+   #endif
+   #ifndef STBI_ONLY_TGA
+   #define STBI_NO_TGA
+   #endif
+   #ifndef STBI_ONLY_GIF
+   #define STBI_NO_GIF
+   #endif
+   #ifndef STBI_ONLY_HDR
+   #define STBI_NO_HDR
+   #endif
+   #ifndef STBI_ONLY_PIC
+   #define STBI_NO_PIC
+   #endif
+   #ifndef STBI_ONLY_PNM
+   #define STBI_NO_PNM
+   #endif
+#endif
+
+#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)
+#define STBI_NO_ZLIB
+#endif
+
+
+#include <stdarg.h>
+#include <stddef.h> // ptrdiff_t on osx
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
+#include <math.h>  // ldexp, pow
+#endif
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif
+
+#ifndef STBI_ASSERT
+#include <assert.h>
+#define STBI_ASSERT(x) assert(x)
+#endif
+
+
+#ifndef _MSC_VER
+   #ifdef __cplusplus
+   #define stbi_inline inline
+   #else
+   #define stbi_inline
+   #endif
+#else
+   #define stbi_inline __forceinline
+#endif
+
+
+#ifdef _MSC_VER
+typedef unsigned short stbi__uint16;
+typedef   signed short stbi__int16;
+typedef unsigned int   stbi__uint32;
+typedef   signed int   stbi__int32;
+#else
+#include <stdint.h>
+typedef uint16_t stbi__uint16;
+typedef int16_t  stbi__int16;
+typedef uint32_t stbi__uint32;
+typedef int32_t  stbi__int32;
+#endif
+
+// should produce compiler error if size is wrong
+typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
+
+#ifdef _MSC_VER
+#define STBI_NOTUSED(v)  (void)(v)
+#else
+#define STBI_NOTUSED(v)  (void)sizeof(v)
+#endif
+
+#ifdef _MSC_VER
+#define STBI_HAS_LROTL
+#endif
+
+#ifdef STBI_HAS_LROTL
+   #define stbi_lrot(x,y)  _lrotl(x,y)
+#else
+   #define stbi_lrot(x,y)  (((x) << (y)) | ((x) >> (32 - (y))))
+#endif
+
+#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))
+// ok
+#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)
+// ok
+#else
+#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."
+#endif
+
+#ifndef STBI_MALLOC
+#define STBI_MALLOC(sz)           malloc(sz)
+#define STBI_REALLOC(p,newsz)     realloc(p,newsz)
+#define STBI_FREE(p)              free(p)
+#endif
+
+#ifndef STBI_REALLOC_SIZED
+#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)
+#endif
+
+// x86/x64 detection
+#if defined(__x86_64__) || defined(_M_X64)
+#define STBI__X64_TARGET
+#elif defined(__i386) || defined(_M_IX86)
+#define STBI__X86_TARGET
+#endif
+
+#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
+// gcc doesn't support sse2 intrinsics unless you compile with -msse2,
+// which in turn means it gets to use SSE2 everywhere. This is unfortunate,
+// but previous attempts to provide the SSE2 functions with runtime
+// detection caused numerous issues. The way architecture extensions are
+// exposed in GCC/Clang is, sadly, not really suited for one-file libs.
+// New behavior: if compiled with -msse2, we use SSE2 without any
+// detection; if not, we don't use it at all.
+#define STBI_NO_SIMD
+#endif
+
+#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)
+// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET
+//
+// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the
+// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.
+// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not
+// simultaneously enabling "-mstackrealign".
+//
+// See https://github.com/nothings/stb/issues/81 for more information.
+//
+// So default to no SSE2 on 32-bit MinGW. If you've read this far and added
+// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.
+#define STBI_NO_SIMD
+#endif
+
+#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))
+#define STBI_SSE2
+#include <emmintrin.h>
+
+#ifdef _MSC_VER
+
+#if _MSC_VER >= 1400  // not VC6
+#include <intrin.h> // __cpuid
+static int stbi__cpuid3(void)
+{
+   int info[4];
+   __cpuid(info,1);
+   return info[3];
+}
+#else
+static int stbi__cpuid3(void)
+{
+   int res;
+   __asm {
+      mov  eax,1
+      cpuid
+      mov  res,edx
+   }
+   return res;
+}
+#endif
+
+#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
+
+static int stbi__sse2_available(void)
+{
+   int info3 = stbi__cpuid3();
+   return ((info3 >> 26) & 1) != 0;
+}
+#else // assume GCC-style if not VC++
+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+
+static int stbi__sse2_available(void)
+{
+   // If we're even attempting to compile this on GCC/Clang, that means
+   // -msse2 is on, which means the compiler is allowed to use SSE2
+   // instructions at will, and so are we.
+   return 1;
+}
+#endif
+#endif
+
+// ARM NEON
+#if defined(STBI_NO_SIMD) && defined(STBI_NEON)
+#undef STBI_NEON
+#endif
+
+#ifdef STBI_NEON
+#include <arm_neon.h>
+// assume GCC or Clang on ARM targets
+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+#endif
+
+#ifndef STBI_SIMD_ALIGN
+#define STBI_SIMD_ALIGN(type, name) type name
+#endif
+
+///////////////////////////////////////////////
+//
+//  stbi__context struct and start_xxx functions
+
+// stbi__context structure is our basic context used by all images, so it
+// contains all the IO context, plus some basic image information
+typedef struct
+{
+   stbi__uint32 img_x, img_y;
+   int img_n, img_out_n;
+
+   stbi_io_callbacks io;
+   void *io_user_data;
+
+   int read_from_callbacks;
+   int buflen;
+   stbi_uc buffer_start[128];
+
+   stbi_uc *img_buffer, *img_buffer_end;
+   stbi_uc *img_buffer_original, *img_buffer_original_end;
+} stbi__context;
+
+
+static void stbi__refill_buffer(stbi__context *s);
+
+// initialize a memory-decode context
+static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
+{
+   s->io.read = NULL;
+   s->read_from_callbacks = 0;
+   s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;
+   s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;
+}
+
+// initialize a callback-based context
+static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
+{
+   s->io = *c;
+   s->io_user_data = user;
+   s->buflen = sizeof(s->buffer_start);
+   s->read_from_callbacks = 1;
+   s->img_buffer_original = s->buffer_start;
+   stbi__refill_buffer(s);
+   s->img_buffer_original_end = s->img_buffer_end;
+}
+
+#ifndef STBI_NO_STDIO
+
+static int stbi__stdio_read(void *user, char *data, int size)
+{
+   return (int) fread(data,1,size,(FILE*) user);
+}
+
+static void stbi__stdio_skip(void *user, int n)
+{
+   fseek((FILE*) user, n, SEEK_CUR);
+}
+
+static int stbi__stdio_eof(void *user)
+{
+   return feof((FILE*) user);
+}
+
+static stbi_io_callbacks stbi__stdio_callbacks =
+{
+   stbi__stdio_read,
+   stbi__stdio_skip,
+   stbi__stdio_eof,
+};
+
+static void stbi__start_file(stbi__context *s, FILE *f)
+{
+   stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);
+}
+
+//static void stop_file(stbi__context *s) { }
+
+#endif // !STBI_NO_STDIO
+
+static void stbi__rewind(stbi__context *s)
+{
+   // conceptually rewind SHOULD rewind to the beginning of the stream,
+   // but we just rewind to the beginning of the initial buffer, because
+   // we only use it after doing 'test', which only ever looks at at most 92 bytes
+   s->img_buffer = s->img_buffer_original;
+   s->img_buffer_end = s->img_buffer_original_end;
+}
+
+enum
+{
+   STBI_ORDER_RGB,
+   STBI_ORDER_BGR
+};
+
+typedef struct
+{
+   int bits_per_channel;
+   int num_channels;
+   int channel_order;
+} stbi__result_info;
+
+#ifndef STBI_NO_JPEG
+static int      stbi__jpeg_test(stbi__context *s);
+static void    *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PNG
+static int      stbi__png_test(stbi__context *s);
+static void    *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__png_info(stbi__context *s, int *x, int *y, int *comp);
+static int      stbi__png_is16(stbi__context *s);
+#endif
+
+#ifndef STBI_NO_BMP
+static int      stbi__bmp_test(stbi__context *s);
+static void    *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_TGA
+static int      stbi__tga_test(stbi__context *s);
+static void    *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PSD
+static int      stbi__psd_test(stbi__context *s);
+static void    *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc);
+static int      stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);
+static int      stbi__psd_is16(stbi__context *s);
+#endif
+
+#ifndef STBI_NO_HDR
+static int      stbi__hdr_test(stbi__context *s);
+static float   *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PIC
+static int      stbi__pic_test(stbi__context *s);
+static void    *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_GIF
+static int      stbi__gif_test(stbi__context *s);
+static void    *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static void    *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
+static int      stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PNM
+static int      stbi__pnm_test(stbi__context *s);
+static void    *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+// this is not threadsafe
+static const char *stbi__g_failure_reason;
+
+STBIDEF const char *stbi_failure_reason(void)
+{
+   return stbi__g_failure_reason;
+}
+
+static int stbi__err(const char *str)
+{
+   stbi__g_failure_reason = str;
+   return 0;
+}
+
+static void *stbi__malloc(size_t size)
+{
+    return STBI_MALLOC(size);
+}
+
+// stb_image uses ints pervasively, including for offset calculations.
+// therefore the largest decoded image size we can support with the
+// current code, even on 64-bit targets, is INT_MAX. this is not a
+// significant limitation for the intended use case.
+//
+// we do, however, need to make sure our size calculations don't
+// overflow. hence a few helper functions for size calculations that
+// multiply integers together, making sure that they're non-negative
+// and no overflow occurs.
+
+// return 1 if the sum is valid, 0 on overflow.
+// negative terms are considered invalid.
+static int stbi__addsizes_valid(int a, int b)
+{
+   if (b < 0) return 0;
+   // now 0 <= b <= INT_MAX, hence also
+   // 0 <= INT_MAX - b <= INTMAX.
+   // And "a + b <= INT_MAX" (which might overflow) is the
+   // same as a <= INT_MAX - b (no overflow)
+   return a <= INT_MAX - b;
+}
+
+// returns 1 if the product is valid, 0 on overflow.
+// negative factors are considered invalid.
+static int stbi__mul2sizes_valid(int a, int b)
+{
+   if (a < 0 || b < 0) return 0;
+   if (b == 0) return 1; // mul-by-0 is always safe
+   // portable way to check for no overflows in a*b
+   return a <= INT_MAX/b;
+}
+
+// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow
+static int stbi__mad2sizes_valid(int a, int b, int add)
+{
+   return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);
+}
+
+// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow
+static int stbi__mad3sizes_valid(int a, int b, int c, int add)
+{
+   return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
+      stbi__addsizes_valid(a*b*c, add);
+}
+
+// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
+static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
+{
+   return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
+      stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);
+}
+#endif
+
+// mallocs with size overflow checking
+static void *stbi__malloc_mad2(int a, int b, int add)
+{
+   if (!stbi__mad2sizes_valid(a, b, add)) return NULL;
+   return stbi__malloc(a*b + add);
+}
+
+static void *stbi__malloc_mad3(int a, int b, int c, int add)
+{
+   if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL;
+   return stbi__malloc(a*b*c + add);
+}
+
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
+static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)
+{
+   if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL;
+   return stbi__malloc(a*b*c*d + add);
+}
+#endif
+
+// stbi__err - error
+// stbi__errpf - error returning pointer to float
+// stbi__errpuc - error returning pointer to unsigned char
+
+#ifdef STBI_NO_FAILURE_STRINGS
+   #define stbi__err(x,y)  0
+#elif defined(STBI_FAILURE_USERMSG)
+   #define stbi__err(x,y)  stbi__err(y)
+#else
+   #define stbi__err(x,y)  stbi__err(x)
+#endif
+
+#define stbi__errpf(x,y)   ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))
+#define stbi__errpuc(x,y)  ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))
+
+STBIDEF void stbi_image_free(void *retval_from_stbi_load)
+{
+   STBI_FREE(retval_from_stbi_load);
+}
+
+#ifndef STBI_NO_LINEAR
+static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
+#endif
+
+#ifndef STBI_NO_HDR
+static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp);
+#endif
+
+static int stbi__vertically_flip_on_load = 0;
+
+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
+{
+    stbi__vertically_flip_on_load = flag_true_if_should_flip;
+}
+
+static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
+{
+   memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields
+   ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed
+   ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order
+   ri->num_channels = 0;
+
+   #ifndef STBI_NO_JPEG
+   if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_PNG
+   if (stbi__png_test(s))  return stbi__png_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_BMP
+   if (stbi__bmp_test(s))  return stbi__bmp_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_GIF
+   if (stbi__gif_test(s))  return stbi__gif_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_test(s))  return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);
+   #endif
+   #ifndef STBI_NO_PIC
+   if (stbi__pic_test(s))  return stbi__pic_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_PNM
+   if (stbi__pnm_test(s))  return stbi__pnm_load(s,x,y,comp,req_comp, ri);
+   #endif
+
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_test(s)) {
+      float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri);
+      return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
+   }
+   #endif
+
+   #ifndef STBI_NO_TGA
+   // test tga last because it's a crappy test!
+   if (stbi__tga_test(s))
+      return stbi__tga_load(s,x,y,comp,req_comp, ri);
+   #endif
+
+   return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");
+}
+
+static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)
+{
+   int i;
+   int img_len = w * h * channels;
+   stbi_uc *reduced;
+
+   reduced = (stbi_uc *) stbi__malloc(img_len);
+   if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory");
+
+   for (i = 0; i < img_len; ++i)
+      reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling
+
+   STBI_FREE(orig);
+   return reduced;
+}
+
+static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)
+{
+   int i;
+   int img_len = w * h * channels;
+   stbi__uint16 *enlarged;
+
+   enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
+   if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
+
+   for (i = 0; i < img_len; ++i)
+      enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff
+
+   STBI_FREE(orig);
+   return enlarged;
+}
+
+static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
+{
+   int row;
+   size_t bytes_per_row = (size_t)w * bytes_per_pixel;
+   stbi_uc temp[2048];
+   stbi_uc *bytes = (stbi_uc *)image;
+
+   for (row = 0; row < (h>>1); row++) {
+      stbi_uc *row0 = bytes + row*bytes_per_row;
+      stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;
+      // swap row0 with row1
+      size_t bytes_left = bytes_per_row;
+      while (bytes_left) {
+         size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);
+         memcpy(temp, row0, bytes_copy);
+         memcpy(row0, row1, bytes_copy);
+         memcpy(row1, temp, bytes_copy);
+         row0 += bytes_copy;
+         row1 += bytes_copy;
+         bytes_left -= bytes_copy;
+      }
+   }
+}
+
+static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)
+{
+   int slice;
+   int slice_size = w * h * bytes_per_pixel;
+
+   stbi_uc *bytes = (stbi_uc *)image;
+   for (slice = 0; slice < z; ++slice) {
+      stbi__vertical_flip(bytes, w, h, bytes_per_pixel); 
+      bytes += slice_size; 
+   }
+}
+
+static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__result_info ri;
+   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
+
+   if (result == NULL)
+      return NULL;
+
+   if (ri.bits_per_channel != 8) {
+      STBI_ASSERT(ri.bits_per_channel == 16);
+      result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
+      ri.bits_per_channel = 8;
+   }
+
+   // @TODO: move stbi__convert_format to here
+
+   if (stbi__vertically_flip_on_load) {
+      int channels = req_comp ? req_comp : *comp;
+      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));
+   }
+
+   return (unsigned char *) result;
+}
+
+static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__result_info ri;
+   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
+
+   if (result == NULL)
+      return NULL;
+
+   if (ri.bits_per_channel != 16) {
+      STBI_ASSERT(ri.bits_per_channel == 8);
+      result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
+      ri.bits_per_channel = 16;
+   }
+
+   // @TODO: move stbi__convert_format16 to here
+   // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision
+
+   if (stbi__vertically_flip_on_load) {
+      int channels = req_comp ? req_comp : *comp;
+      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));
+   }
+
+   return (stbi__uint16 *) result;
+}
+
+#if !defined(STBI_NO_HDR) || !defined(STBI_NO_LINEAR)
+static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)
+{
+   if (stbi__vertically_flip_on_load && result != NULL) {
+      int channels = req_comp ? req_comp : *comp;
+      stbi__vertical_flip(result, *x, *y, channels * sizeof(float));
+   }
+}
+#endif
+
+#ifndef STBI_NO_STDIO
+
+static FILE *stbi__fopen(char const *filename, char const *mode)
+{
+   FILE *f;
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+   if (0 != fopen_s(&f, filename, mode))
+      f=0;
+#else
+   f = fopen(filename, mode);
+#endif
+   return f;
+}
+
+
+STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   unsigned char *result;
+   if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
+   result = stbi_load_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   unsigned char *result;
+   stbi__context s;
+   stbi__start_file(&s,f);
+   result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+   if (result) {
+      // need to 'unget' all the characters in the IO buffer
+      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+   }
+   return result;
+}
+
+STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__uint16 *result;
+   stbi__context s;
+   stbi__start_file(&s,f);
+   result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
+   if (result) {
+      // need to 'unget' all the characters in the IO buffer
+      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+   }
+   return result;
+}
+
+STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   stbi__uint16 *result;
+   if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");
+   result = stbi_load_from_file_16(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+
+#endif //!STBI_NO_STDIO
+
+STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+}
+
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
+   return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+}
+
+STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+}
+
+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
+{
+   unsigned char *result;
+   stbi__context s; 
+   stbi__start_mem(&s,buffer,len); 
+   
+   result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
+   if (stbi__vertically_flip_on_load) {
+      stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); 
+   }
+
+   return result; 
+}
+#endif
+
+#ifndef STBI_NO_LINEAR
+static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   unsigned char *data;
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_test(s)) {
+      stbi__result_info ri;
+      float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
+      if (hdr_data)
+         stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
+      return hdr_data;
+   }
+   #endif
+   data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
+   if (data)
+      return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
+   return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
+}
+
+STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+
+STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   float *result;
+   FILE *f = stbi__fopen(filename, "rb");
+   if (!f) return stbi__errpf("can't fopen", "Unable to open file");
+   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_file(&s,f);
+   return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+#endif // !STBI_NO_STDIO
+
+#endif // !STBI_NO_LINEAR
+
+// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is
+// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always
+// reports false!
+
+STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
+{
+   #ifndef STBI_NO_HDR
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__hdr_test(&s);
+   #else
+   STBI_NOTUSED(buffer);
+   STBI_NOTUSED(len);
+   return 0;
+   #endif
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF int      stbi_is_hdr          (char const *filename)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   int result=0;
+   if (f) {
+      result = stbi_is_hdr_from_file(f);
+      fclose(f);
+   }
+   return result;
+}
+
+STBIDEF int stbi_is_hdr_from_file(FILE *f)
+{
+   #ifndef STBI_NO_HDR
+   long pos = ftell(f);
+   int res;
+   stbi__context s;
+   stbi__start_file(&s,f);
+   res = stbi__hdr_test(&s);
+   fseek(f, pos, SEEK_SET);
+   return res;
+   #else
+   STBI_NOTUSED(f);
+   return 0;
+   #endif
+}
+#endif // !STBI_NO_STDIO
+
+STBIDEF int      stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
+{
+   #ifndef STBI_NO_HDR
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__hdr_test(&s);
+   #else
+   STBI_NOTUSED(clbk);
+   STBI_NOTUSED(user);
+   return 0;
+   #endif
+}
+
+#ifndef STBI_NO_LINEAR
+static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;
+
+STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }
+STBIDEF void   stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }
+#endif
+
+static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
+
+STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }
+STBIDEF void   stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Common code used by all image loaders
+//
+
+enum
+{
+   STBI__SCAN_load=0,
+   STBI__SCAN_type,
+   STBI__SCAN_header
+};
+
+static void stbi__refill_buffer(stbi__context *s)
+{
+   int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
+   if (n == 0) {
+      // at end of file, treat same as if from memory, but need to handle case
+      // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
+      s->read_from_callbacks = 0;
+      s->img_buffer = s->buffer_start;
+      s->img_buffer_end = s->buffer_start+1;
+      *s->img_buffer = 0;
+   } else {
+      s->img_buffer = s->buffer_start;
+      s->img_buffer_end = s->buffer_start + n;
+   }
+}
+
+stbi_inline static stbi_uc stbi__get8(stbi__context *s)
+{
+   if (s->img_buffer < s->img_buffer_end)
+      return *s->img_buffer++;
+   if (s->read_from_callbacks) {
+      stbi__refill_buffer(s);
+      return *s->img_buffer++;
+   }
+   return 0;
+}
+
+stbi_inline static int stbi__at_eof(stbi__context *s)
+{
+   if (s->io.read) {
+      if (!(s->io.eof)(s->io_user_data)) return 0;
+      // if feof() is true, check if buffer = end
+      // special case: we've only got the special 0 character at the end
+      if (s->read_from_callbacks == 0) return 1;
+   }
+
+   return s->img_buffer >= s->img_buffer_end;
+}
+
+static void stbi__skip(stbi__context *s, int n)
+{
+   if (n < 0) {
+      s->img_buffer = s->img_buffer_end;
+      return;
+   }
+   if (s->io.read) {
+      int blen = (int) (s->img_buffer_end - s->img_buffer);
+      if (blen < n) {
+         s->img_buffer = s->img_buffer_end;
+         (s->io.skip)(s->io_user_data, n - blen);
+         return;
+      }
+   }
+   s->img_buffer += n;
+}
+
+static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
+{
+   if (s->io.read) {
+      int blen = (int) (s->img_buffer_end - s->img_buffer);
+      if (blen < n) {
+         int res, count;
+
+         memcpy(buffer, s->img_buffer, blen);
+
+         count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
+         res = (count == (n-blen));
+         s->img_buffer = s->img_buffer_end;
+         return res;
+      }
+   }
+
+   if (s->img_buffer+n <= s->img_buffer_end) {
+      memcpy(buffer, s->img_buffer, n);
+      s->img_buffer += n;
+      return 1;
+   } else
+      return 0;
+}
+
+static int stbi__get16be(stbi__context *s)
+{
+   int z = stbi__get8(s);
+   return (z << 8) + stbi__get8(s);
+}
+
+static stbi__uint32 stbi__get32be(stbi__context *s)
+{
+   stbi__uint32 z = stbi__get16be(s);
+   return (z << 16) + stbi__get16be(s);
+}
+
+#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
+// nothing
+#else
+static int stbi__get16le(stbi__context *s)
+{
+   int z = stbi__get8(s);
+   return z + (stbi__get8(s) << 8);
+}
+#endif
+
+#ifndef STBI_NO_BMP
+static stbi__uint32 stbi__get32le(stbi__context *s)
+{
+   stbi__uint32 z = stbi__get16le(s);
+   return z + (stbi__get16le(s) << 16);
+}
+#endif
+
+#define STBI__BYTECAST(x)  ((stbi_uc) ((x) & 255))  // truncate int to byte without warnings
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  generic converter from built-in img_n to req_comp
+//    individual types do this automatically as much as possible (e.g. jpeg
+//    does all cases internally since it needs to colorspace convert anyway,
+//    and it never has alpha, so very few cases ). png can automatically
+//    interleave an alpha=255 channel, but falls back to this for other cases
+//
+//  assume data buffer is malloced, so malloc a new one and free that one
+//  only failure mode is malloc failing
+
+static stbi_uc stbi__compute_y(int r, int g, int b)
+{
+   return (stbi_uc) (((r*77) + (g*150) +  (29*b)) >> 8);
+}
+
+static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
+{
+   int i,j;
+   unsigned char *good;
+
+   if (req_comp == img_n) return data;
+   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+   good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);
+   if (good == NULL) {
+      STBI_FREE(data);
+      return stbi__errpuc("outofmem", "Out of memory");
+   }
+
+   for (j=0; j < (int) y; ++j) {
+      unsigned char *src  = data + j * x * img_n   ;
+      unsigned char *dest = good + j * x * req_comp;
+
+      #define STBI__COMBO(a,b)  ((a)*8+(b))
+      #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
+      // convert source image with img_n components to one with req_comp components;
+      // avoid switch per pixel, so use switch per scanline and massive macros
+      switch (STBI__COMBO(img_n, req_comp)) {
+         STBI__CASE(1,2) { dest[0]=src[0], dest[1]=255;                                     } break;
+         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
+         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=255;                     } break;
+         STBI__CASE(2,1) { dest[0]=src[0];                                                  } break;
+         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
+         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1];                  } break;
+         STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255;        } break;
+         STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = 255;    } break;
+         STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = src[3]; } break;
+         STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2];                    } break;
+         default: STBI_ASSERT(0);
+      }
+      #undef STBI__CASE
+   }
+
+   STBI_FREE(data);
+   return good;
+}
+
+static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
+{
+   return (stbi__uint16) (((r*77) + (g*150) +  (29*b)) >> 8);
+}
+
+static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
+{
+   int i,j;
+   stbi__uint16 *good;
+
+   if (req_comp == img_n) return data;
+   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+   good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);
+   if (good == NULL) {
+      STBI_FREE(data);
+      return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
+   }
+
+   for (j=0; j < (int) y; ++j) {
+      stbi__uint16 *src  = data + j * x * img_n   ;
+      stbi__uint16 *dest = good + j * x * req_comp;
+
+      #define STBI__COMBO(a,b)  ((a)*8+(b))
+      #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
+      // convert source image with img_n components to one with req_comp components;
+      // avoid switch per pixel, so use switch per scanline and massive macros
+      switch (STBI__COMBO(img_n, req_comp)) {
+         STBI__CASE(1,2) { dest[0]=src[0], dest[1]=0xffff;                                     } break;
+         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
+         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=0xffff;                     } break;
+         STBI__CASE(2,1) { dest[0]=src[0];                                                     } break;
+         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
+         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1];                     } break;
+         STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=0xffff;        } break;
+         STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]), dest[1] = 0xffff; } break;
+         STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]), dest[1] = src[3]; } break;
+         STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2];                       } break;
+         default: STBI_ASSERT(0);
+      }
+      #undef STBI__CASE
+   }
+
+   STBI_FREE(data);
+   return good;
+}
+
+#ifndef STBI_NO_LINEAR
+static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
+{
+   int i,k,n;
+   float *output;
+   if (!data) return NULL;
+   output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
+   if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
+   // compute number of non-alpha components
+   if (comp & 1) n = comp; else n = comp-1;
+   for (i=0; i < x*y; ++i) {
+      for (k=0; k < n; ++k) {
+         output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
+      }
+      if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
+   }
+   STBI_FREE(data);
+   return output;
+}
+#endif
+
+#ifndef STBI_NO_HDR
+#define stbi__float2int(x)   ((int) (x))
+static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp)
+{
+   int i,k,n;
+   stbi_uc *output;
+   if (!data) return NULL;
+   output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);
+   if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); }
+   // compute number of non-alpha components
+   if (comp & 1) n = comp; else n = comp-1;
+   for (i=0; i < x*y; ++i) {
+      for (k=0; k < n; ++k) {
+         float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
+         if (z < 0) z = 0;
+         if (z > 255) z = 255;
+         output[i*comp + k] = (stbi_uc) stbi__float2int(z);
+      }
+      if (k < comp) {
+         float z = data[i*comp+k] * 255 + 0.5f;
+         if (z < 0) z = 0;
+         if (z > 255) z = 255;
+         output[i*comp + k] = (stbi_uc) stbi__float2int(z);
+      }
+   }
+   STBI_FREE(data);
+   return output;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  "baseline" JPEG/JFIF decoder
+//
+//    simple implementation
+//      - doesn't support delayed output of y-dimension
+//      - simple interface (only one output format: 8-bit interleaved RGB)
+//      - doesn't try to recover corrupt jpegs
+//      - doesn't allow partial loading, loading multiple at once
+//      - still fast on x86 (copying globals into locals doesn't help x86)
+//      - allocates lots of intermediate memory (full size of all components)
+//        - non-interleaved case requires this anyway
+//        - allows good upsampling (see next)
+//    high-quality
+//      - upsampled channels are bilinearly interpolated, even across blocks
+//      - quality integer IDCT derived from IJG's 'slow'
+//    performance
+//      - fast huffman; reasonable integer IDCT
+//      - some SIMD kernels for common paths on targets with SSE2/NEON
+//      - uses a lot of intermediate memory, could cache poorly
+
+#ifndef STBI_NO_JPEG
+
+// huffman decoding acceleration
+#define FAST_BITS   9  // larger handles more cases; smaller stomps less cache
+
+typedef struct
+{
+   stbi_uc  fast[1 << FAST_BITS];
+   // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
+   stbi__uint16 code[256];
+   stbi_uc  values[256];
+   stbi_uc  size[257];
+   unsigned int maxcode[18];
+   int    delta[17];   // old 'firstsymbol' - old 'firstcode'
+} stbi__huffman;
+
+typedef struct
+{
+   stbi__context *s;
+   stbi__huffman huff_dc[4];
+   stbi__huffman huff_ac[4];
+   stbi__uint16 dequant[4][64];
+   stbi__int16 fast_ac[4][1 << FAST_BITS];
+
+// sizes for components, interleaved MCUs
+   int img_h_max, img_v_max;
+   int img_mcu_x, img_mcu_y;
+   int img_mcu_w, img_mcu_h;
+
+// definition of jpeg image component
+   struct
+   {
+      int id;
+      int h,v;
+      int tq;
+      int hd,ha;
+      int dc_pred;
+
+      int x,y,w2,h2;
+      stbi_uc *data;
+      void *raw_data, *raw_coeff;
+      stbi_uc *linebuf;
+      short   *coeff;   // progressive only
+      int      coeff_w, coeff_h; // number of 8x8 coefficient blocks
+   } img_comp[4];
+
+   stbi__uint32   code_buffer; // jpeg entropy-coded buffer
+   int            code_bits;   // number of valid bits
+   unsigned char  marker;      // marker seen while filling entropy buffer
+   int            nomore;      // flag if we saw a marker so must stop
+
+   int            progressive;
+   int            spec_start;
+   int            spec_end;
+   int            succ_high;
+   int            succ_low;
+   int            eob_run;
+   int            jfif;
+   int            app14_color_transform; // Adobe APP14 tag
+   int            rgb;
+
+   int scan_n, order[4];
+   int restart_interval, todo;
+
+// kernels
+   void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);
+   void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);
+   stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);
+} stbi__jpeg;
+
+static int stbi__build_huffman(stbi__huffman *h, int *count)
+{
+   int i,j,k=0;
+   unsigned int code;
+   // build size list for each symbol (from JPEG spec)
+   for (i=0; i < 16; ++i)
+      for (j=0; j < count[i]; ++j)
+         h->size[k++] = (stbi_uc) (i+1);
+   h->size[k] = 0;
+
+   // compute actual symbols (from jpeg spec)
+   code = 0;
+   k = 0;
+   for(j=1; j <= 16; ++j) {
+      // compute delta to add to code to compute symbol id
+      h->delta[j] = k - code;
+      if (h->size[k] == j) {
+         while (h->size[k] == j)
+            h->code[k++] = (stbi__uint16) (code++);
+         if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG");
+      }
+      // compute largest code + 1 for this size, preshifted as needed later
+      h->maxcode[j] = code << (16-j);
+      code <<= 1;
+   }
+   h->maxcode[j] = 0xffffffff;
+
+   // build non-spec acceleration table; 255 is flag for not-accelerated
+   memset(h->fast, 255, 1 << FAST_BITS);
+   for (i=0; i < k; ++i) {
+      int s = h->size[i];
+      if (s <= FAST_BITS) {
+         int c = h->code[i] << (FAST_BITS-s);
+         int m = 1 << (FAST_BITS-s);
+         for (j=0; j < m; ++j) {
+            h->fast[c+j] = (stbi_uc) i;
+         }
+      }
+   }
+   return 1;
+}
+
+// build a table that decodes both magnitude and value of small ACs in
+// one go.
+static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
+{
+   int i;
+   for (i=0; i < (1 << FAST_BITS); ++i) {
+      stbi_uc fast = h->fast[i];
+      fast_ac[i] = 0;
+      if (fast < 255) {
+         int rs = h->values[fast];
+         int run = (rs >> 4) & 15;
+         int magbits = rs & 15;
+         int len = h->size[fast];
+
+         if (magbits && len + magbits <= FAST_BITS) {
+            // magnitude code followed by receive_extend code
+            int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
+            int m = 1 << (magbits - 1);
+            if (k < m) k += (~0U << magbits) + 1;
+            // if the result is small enough, we can fit it in fast_ac table
+            if (k >= -128 && k <= 127)
+               fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));
+         }
+      }
+   }
+}
+
+static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
+{
+   do {
+      unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
+      if (b == 0xff) {
+         int c = stbi__get8(j->s);
+         while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
+         if (c != 0) {
+            j->marker = (unsigned char) c;
+            j->nomore = 1;
+            return;
+         }
+      }
+      j->code_buffer |= b << (24 - j->code_bits);
+      j->code_bits += 8;
+   } while (j->code_bits <= 24);
+}
+
+// (1 << n) - 1
+static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
+
+// decode a jpeg huffman value from the bitstream
+stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
+{
+   unsigned int temp;
+   int c,k;
+
+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
+   // look at the top FAST_BITS and determine what symbol ID it is,
+   // if the code is <= FAST_BITS
+   c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+   k = h->fast[c];
+   if (k < 255) {
+      int s = h->size[k];
+      if (s > j->code_bits)
+         return -1;
+      j->code_buffer <<= s;
+      j->code_bits -= s;
+      return h->values[k];
+   }
+
+   // naive test is to shift the code_buffer down so k bits are
+   // valid, then test against maxcode. To speed this up, we've
+   // preshifted maxcode left so that it has (16-k) 0s at the
+   // end; in other words, regardless of the number of bits, it
+   // wants to be compared against something shifted to have 16;
+   // that way we don't need to shift inside the loop.
+   temp = j->code_buffer >> 16;
+   for (k=FAST_BITS+1 ; ; ++k)
+      if (temp < h->maxcode[k])
+         break;
+   if (k == 17) {
+      // error! code not found
+      j->code_bits -= 16;
+      return -1;
+   }
+
+   if (k > j->code_bits)
+      return -1;
+
+   // convert the huffman code to the symbol id
+   c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
+   STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
+
+   // convert the id to a symbol
+   j->code_bits -= k;
+   j->code_buffer <<= k;
+   return h->values[c];
+}
+
+// bias[n] = (-1<<n) + 1
+static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
+
+// combined JPEG 'receive' and JPEG 'extend', since baseline
+// always extends everything it receives.
+stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
+{
+   unsigned int k;
+   int sgn;
+   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+
+   sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB
+   k = stbi_lrot(j->code_buffer, n);
+   STBI_ASSERT(n >= 0 && n < (int) (sizeof(stbi__bmask)/sizeof(*stbi__bmask)));
+   j->code_buffer = k & ~stbi__bmask[n];
+   k &= stbi__bmask[n];
+   j->code_bits -= n;
+   return k + (stbi__jbias[n] & ~sgn);
+}
+
+// get some unsigned bits
+stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
+{
+   unsigned int k;
+   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+   k = stbi_lrot(j->code_buffer, n);
+   j->code_buffer = k & ~stbi__bmask[n];
+   k &= stbi__bmask[n];
+   j->code_bits -= n;
+   return k;
+}
+
+stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)
+{
+   unsigned int k;
+   if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
+   k = j->code_buffer;
+   j->code_buffer <<= 1;
+   --j->code_bits;
+   return k & 0x80000000;
+}
+
+// given a value that's at position X in the zigzag stream,
+// where does it appear in the 8x8 matrix coded as row-major?
+static const stbi_uc stbi__jpeg_dezigzag[64+15] =
+{
+    0,  1,  8, 16,  9,  2,  3, 10,
+   17, 24, 32, 25, 18, 11,  4,  5,
+   12, 19, 26, 33, 40, 48, 41, 34,
+   27, 20, 13,  6,  7, 14, 21, 28,
+   35, 42, 49, 56, 57, 50, 43, 36,
+   29, 22, 15, 23, 30, 37, 44, 51,
+   58, 59, 52, 45, 38, 31, 39, 46,
+   53, 60, 61, 54, 47, 55, 62, 63,
+   // let corrupt input sample past end
+   63, 63, 63, 63, 63, 63, 63, 63,
+   63, 63, 63, 63, 63, 63, 63
+};
+
+// decode one 64-entry block--
+static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)
+{
+   int diff,dc,k;
+   int t;
+
+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+   t = stbi__jpeg_huff_decode(j, hdc);
+   if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+
+   // 0 all the ac values now so we can do it 32-bits at a time
+   memset(data,0,64*sizeof(data[0]));
+
+   diff = t ? stbi__extend_receive(j, t) : 0;
+   dc = j->img_comp[b].dc_pred + diff;
+   j->img_comp[b].dc_pred = dc;
+   data[0] = (short) (dc * dequant[0]);
+
+   // decode AC components, see JPEG spec
+   k = 1;
+   do {
+      unsigned int zig;
+      int c,r,s;
+      if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+      c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+      r = fac[c];
+      if (r) { // fast-AC path
+         k += (r >> 4) & 15; // run
+         s = r & 15; // combined length
+         j->code_buffer <<= s;
+         j->code_bits -= s;
+         // decode into unzigzag'd location
+         zig = stbi__jpeg_dezigzag[k++];
+         data[zig] = (short) ((r >> 8) * dequant[zig]);
+      } else {
+         int rs = stbi__jpeg_huff_decode(j, hac);
+         if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+         s = rs & 15;
+         r = rs >> 4;
+         if (s == 0) {
+            if (rs != 0xf0) break; // end block
+            k += 16;
+         } else {
+            k += r;
+            // decode into unzigzag'd location
+            zig = stbi__jpeg_dezigzag[k++];
+            data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
+         }
+      }
+   } while (k < 64);
+   return 1;
+}
+
+static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
+{
+   int diff,dc;
+   int t;
+   if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+
+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
+   if (j->succ_high == 0) {
+      // first scan for DC coefficient, must be first
+      memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
+      t = stbi__jpeg_huff_decode(j, hdc);
+      diff = t ? stbi__extend_receive(j, t) : 0;
+
+      dc = j->img_comp[b].dc_pred + diff;
+      j->img_comp[b].dc_pred = dc;
+      data[0] = (short) (dc << j->succ_low);
+   } else {
+      // refinement scan for DC coefficient
+      if (stbi__jpeg_get_bit(j))
+         data[0] += (short) (1 << j->succ_low);
+   }
+   return 1;
+}
+
+// @OPTIMIZE: store non-zigzagged during the decode passes,
+// and only de-zigzag when dequantizing
+static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)
+{
+   int k;
+   if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+
+   if (j->succ_high == 0) {
+      int shift = j->succ_low;
+
+      if (j->eob_run) {
+         --j->eob_run;
+         return 1;
+      }
+
+      k = j->spec_start;
+      do {
+         unsigned int zig;
+         int c,r,s;
+         if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+         c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+         r = fac[c];
+         if (r) { // fast-AC path
+            k += (r >> 4) & 15; // run
+            s = r & 15; // combined length
+            j->code_buffer <<= s;
+            j->code_bits -= s;
+            zig = stbi__jpeg_dezigzag[k++];
+            data[zig] = (short) ((r >> 8) << shift);
+         } else {
+            int rs = stbi__jpeg_huff_decode(j, hac);
+            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+            s = rs & 15;
+            r = rs >> 4;
+            if (s == 0) {
+               if (r < 15) {
+                  j->eob_run = (1 << r);
+                  if (r)
+                     j->eob_run += stbi__jpeg_get_bits(j, r);
+                  --j->eob_run;
+                  break;
+               }
+               k += 16;
+            } else {
+               k += r;
+               zig = stbi__jpeg_dezigzag[k++];
+               data[zig] = (short) (stbi__extend_receive(j,s) << shift);
+            }
+         }
+      } while (k <= j->spec_end);
+   } else {
+      // refinement scan for these AC coefficients
+
+      short bit = (short) (1 << j->succ_low);
+
+      if (j->eob_run) {
+         --j->eob_run;
+         for (k = j->spec_start; k <= j->spec_end; ++k) {
+            short *p = &data[stbi__jpeg_dezigzag[k]];
+            if (*p != 0)
+               if (stbi__jpeg_get_bit(j))
+                  if ((*p & bit)==0) {
+                     if (*p > 0)
+                        *p += bit;
+                     else
+                        *p -= bit;
+                  }
+         }
+      } else {
+         k = j->spec_start;
+         do {
+            int r,s;
+            int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh
+            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+            s = rs & 15;
+            r = rs >> 4;
+            if (s == 0) {
+               if (r < 15) {
+                  j->eob_run = (1 << r) - 1;
+                  if (r)
+                     j->eob_run += stbi__jpeg_get_bits(j, r);
+                  r = 64; // force end of block
+               } else {
+                  // r=15 s=0 should write 16 0s, so we just do
+                  // a run of 15 0s and then write s (which is 0),
+                  // so we don't have to do anything special here
+               }
+            } else {
+               if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG");
+               // sign bit
+               if (stbi__jpeg_get_bit(j))
+                  s = bit;
+               else
+                  s = -bit;
+            }
+
+            // advance by r
+            while (k <= j->spec_end) {
+               short *p = &data[stbi__jpeg_dezigzag[k++]];
+               if (*p != 0) {
+                  if (stbi__jpeg_get_bit(j))
+                     if ((*p & bit)==0) {
+                        if (*p > 0)
+                           *p += bit;
+                        else
+                           *p -= bit;
+                     }
+               } else {
+                  if (r == 0) {
+                     *p = (short) s;
+                     break;
+                  }
+                  --r;
+               }
+            }
+         } while (k <= j->spec_end);
+      }
+   }
+   return 1;
+}
+
+// take a -128..127 value and stbi__clamp it and convert to 0..255
+stbi_inline static stbi_uc stbi__clamp(int x)
+{
+   // trick to use a single test to catch both cases
+   if ((unsigned int) x > 255) {
+      if (x < 0) return 0;
+      if (x > 255) return 255;
+   }
+   return (stbi_uc) x;
+}
+
+#define stbi__f2f(x)  ((int) (((x) * 4096 + 0.5)))
+#define stbi__fsh(x)  ((x) * 4096)
+
+// derived from jidctint -- DCT_ISLOW
+#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
+   int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
+   p2 = s2;                                    \
+   p3 = s6;                                    \
+   p1 = (p2+p3) * stbi__f2f(0.5411961f);       \
+   t2 = p1 + p3*stbi__f2f(-1.847759065f);      \
+   t3 = p1 + p2*stbi__f2f( 0.765366865f);      \
+   p2 = s0;                                    \
+   p3 = s4;                                    \
+   t0 = stbi__fsh(p2+p3);                      \
+   t1 = stbi__fsh(p2-p3);                      \
+   x0 = t0+t3;                                 \
+   x3 = t0-t3;                                 \
+   x1 = t1+t2;                                 \
+   x2 = t1-t2;                                 \
+   t0 = s7;                                    \
+   t1 = s5;                                    \
+   t2 = s3;                                    \
+   t3 = s1;                                    \
+   p3 = t0+t2;                                 \
+   p4 = t1+t3;                                 \
+   p1 = t0+t3;                                 \
+   p2 = t1+t2;                                 \
+   p5 = (p3+p4)*stbi__f2f( 1.175875602f);      \
+   t0 = t0*stbi__f2f( 0.298631336f);           \
+   t1 = t1*stbi__f2f( 2.053119869f);           \
+   t2 = t2*stbi__f2f( 3.072711026f);           \
+   t3 = t3*stbi__f2f( 1.501321110f);           \
+   p1 = p5 + p1*stbi__f2f(-0.899976223f);      \
+   p2 = p5 + p2*stbi__f2f(-2.562915447f);      \
+   p3 = p3*stbi__f2f(-1.961570560f);           \
+   p4 = p4*stbi__f2f(-0.390180644f);           \
+   t3 += p1+p4;                                \
+   t2 += p2+p3;                                \
+   t1 += p2+p4;                                \
+   t0 += p1+p3;
+
+static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
+{
+   int i,val[64],*v=val;
+   stbi_uc *o;
+   short *d = data;
+
+   // columns
+   for (i=0; i < 8; ++i,++d, ++v) {
+      // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
+      if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
+           && d[40]==0 && d[48]==0 && d[56]==0) {
+         //    no shortcut                 0     seconds
+         //    (1|2|3|4|5|6|7)==0          0     seconds
+         //    all separate               -0.047 seconds
+         //    1 && 2|3 && 4|5 && 6|7:    -0.047 seconds
+         int dcterm = d[0]*4;
+         v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
+      } else {
+         STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])
+         // constants scaled things up by 1<<12; let's bring them back
+         // down, but keep 2 extra bits of precision
+         x0 += 512; x1 += 512; x2 += 512; x3 += 512;
+         v[ 0] = (x0+t3) >> 10;
+         v[56] = (x0-t3) >> 10;
+         v[ 8] = (x1+t2) >> 10;
+         v[48] = (x1-t2) >> 10;
+         v[16] = (x2+t1) >> 10;
+         v[40] = (x2-t1) >> 10;
+         v[24] = (x3+t0) >> 10;
+         v[32] = (x3-t0) >> 10;
+      }
+   }
+
+   for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
+      // no fast case since the first 1D IDCT spread components out
+      STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
+      // constants scaled things up by 1<<12, plus we had 1<<2 from first
+      // loop, plus horizontal and vertical each scale by sqrt(8) so together
+      // we've got an extra 1<<3, so 1<<17 total we need to remove.
+      // so we want to round that, which means adding 0.5 * 1<<17,
+      // aka 65536. Also, we'll end up with -128 to 127 that we want
+      // to encode as 0..255 by adding 128, so we'll add that before the shift
+      x0 += 65536 + (128<<17);
+      x1 += 65536 + (128<<17);
+      x2 += 65536 + (128<<17);
+      x3 += 65536 + (128<<17);
+      // tried computing the shifts into temps, or'ing the temps to see
+      // if any were out of range, but that was slower
+      o[0] = stbi__clamp((x0+t3) >> 17);
+      o[7] = stbi__clamp((x0-t3) >> 17);
+      o[1] = stbi__clamp((x1+t2) >> 17);
+      o[6] = stbi__clamp((x1-t2) >> 17);
+      o[2] = stbi__clamp((x2+t1) >> 17);
+      o[5] = stbi__clamp((x2-t1) >> 17);
+      o[3] = stbi__clamp((x3+t0) >> 17);
+      o[4] = stbi__clamp((x3-t0) >> 17);
+   }
+}
+
+#ifdef STBI_SSE2
+// sse2 integer IDCT. not the fastest possible implementation but it
+// produces bit-identical results to the generic C version so it's
+// fully "transparent".
+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
+{
+   // This is constructed to match our regular (generic) integer IDCT exactly.
+   __m128i row0, row1, row2, row3, row4, row5, row6, row7;
+   __m128i tmp;
+
+   // dot product constant: even elems=x, odd elems=y
+   #define dct_const(x,y)  _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))
+
+   // out(0) = c0[even]*x + c0[odd]*y   (c0, x, y 16-bit, out 32-bit)
+   // out(1) = c1[even]*x + c1[odd]*y
+   #define dct_rot(out0,out1, x,y,c0,c1) \
+      __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \
+      __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \
+      __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \
+      __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \
+      __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \
+      __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
+
+   // out = in << 12  (in 16-bit, out 32-bit)
+   #define dct_widen(out, in) \
+      __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \
+      __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
+
+   // wide add
+   #define dct_wadd(out, a, b) \
+      __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \
+      __m128i out##_h = _mm_add_epi32(a##_h, b##_h)
+
+   // wide sub
+   #define dct_wsub(out, a, b) \
+      __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \
+      __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
+
+   // butterfly a/b, add bias, then shift by "s" and pack
+   #define dct_bfly32o(out0, out1, a,b,bias,s) \
+      { \
+         __m128i abiased_l = _mm_add_epi32(a##_l, bias); \
+         __m128i abiased_h = _mm_add_epi32(a##_h, bias); \
+         dct_wadd(sum, abiased, b); \
+         dct_wsub(dif, abiased, b); \
+         out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \
+         out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \
+      }
+
+   // 8-bit interleave step (for transposes)
+   #define dct_interleave8(a, b) \
+      tmp = a; \
+      a = _mm_unpacklo_epi8(a, b); \
+      b = _mm_unpackhi_epi8(tmp, b)
+
+   // 16-bit interleave step (for transposes)
+   #define dct_interleave16(a, b) \
+      tmp = a; \
+      a = _mm_unpacklo_epi16(a, b); \
+      b = _mm_unpackhi_epi16(tmp, b)
+
+   #define dct_pass(bias,shift) \
+      { \
+         /* even part */ \
+         dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \
+         __m128i sum04 = _mm_add_epi16(row0, row4); \
+         __m128i dif04 = _mm_sub_epi16(row0, row4); \
+         dct_widen(t0e, sum04); \
+         dct_widen(t1e, dif04); \
+         dct_wadd(x0, t0e, t3e); \
+         dct_wsub(x3, t0e, t3e); \
+         dct_wadd(x1, t1e, t2e); \
+         dct_wsub(x2, t1e, t2e); \
+         /* odd part */ \
+         dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \
+         dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \
+         __m128i sum17 = _mm_add_epi16(row1, row7); \
+         __m128i sum35 = _mm_add_epi16(row3, row5); \
+         dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \
+         dct_wadd(x4, y0o, y4o); \
+         dct_wadd(x5, y1o, y5o); \
+         dct_wadd(x6, y2o, y5o); \
+         dct_wadd(x7, y3o, y4o); \
+         dct_bfly32o(row0,row7, x0,x7,bias,shift); \
+         dct_bfly32o(row1,row6, x1,x6,bias,shift); \
+         dct_bfly32o(row2,row5, x2,x5,bias,shift); \
+         dct_bfly32o(row3,row4, x3,x4,bias,shift); \
+      }
+
+   __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));
+   __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));
+   __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));
+   __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));
+   __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));
+   __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));
+   __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));
+   __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));
+
+   // rounding biases in column/row passes, see stbi__idct_block for explanation.
+   __m128i bias_0 = _mm_set1_epi32(512);
+   __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));
+
+   // load
+   row0 = _mm_load_si128((const __m128i *) (data + 0*8));
+   row1 = _mm_load_si128((const __m128i *) (data + 1*8));
+   row2 = _mm_load_si128((const __m128i *) (data + 2*8));
+   row3 = _mm_load_si128((const __m128i *) (data + 3*8));
+   row4 = _mm_load_si128((const __m128i *) (data + 4*8));
+   row5 = _mm_load_si128((const __m128i *) (data + 5*8));
+   row6 = _mm_load_si128((const __m128i *) (data + 6*8));
+   row7 = _mm_load_si128((const __m128i *) (data + 7*8));
+
+   // column pass
+   dct_pass(bias_0, 10);
+
+   {
+      // 16bit 8x8 transpose pass 1
+      dct_interleave16(row0, row4);
+      dct_interleave16(row1, row5);
+      dct_interleave16(row2, row6);
+      dct_interleave16(row3, row7);
+
+      // transpose pass 2
+      dct_interleave16(row0, row2);
+      dct_interleave16(row1, row3);
+      dct_interleave16(row4, row6);
+      dct_interleave16(row5, row7);
+
+      // transpose pass 3
+      dct_interleave16(row0, row1);
+      dct_interleave16(row2, row3);
+      dct_interleave16(row4, row5);
+      dct_interleave16(row6, row7);
+   }
+
+   // row pass
+   dct_pass(bias_1, 17);
+
+   {
+      // pack
+      __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7
+      __m128i p1 = _mm_packus_epi16(row2, row3);
+      __m128i p2 = _mm_packus_epi16(row4, row5);
+      __m128i p3 = _mm_packus_epi16(row6, row7);
+
+      // 8bit 8x8 transpose pass 1
+      dct_interleave8(p0, p2); // a0e0a1e1...
+      dct_interleave8(p1, p3); // c0g0c1g1...
+
+      // transpose pass 2
+      dct_interleave8(p0, p1); // a0c0e0g0...
+      dct_interleave8(p2, p3); // b0d0f0h0...
+
+      // transpose pass 3
+      dct_interleave8(p0, p2); // a0b0c0d0...
+      dct_interleave8(p1, p3); // a4b4c4d4...
+
+      // store
+      _mm_storel_epi64((__m128i *) out, p0); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, p2); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, p1); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, p3); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));
+   }
+
+#undef dct_const
+#undef dct_rot
+#undef dct_widen
+#undef dct_wadd
+#undef dct_wsub
+#undef dct_bfly32o
+#undef dct_interleave8
+#undef dct_interleave16
+#undef dct_pass
+}
+
+#endif // STBI_SSE2
+
+#ifdef STBI_NEON
+
+// NEON integer IDCT. should produce bit-identical
+// results to the generic C version.
+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
+{
+   int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
+
+   int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));
+   int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));
+   int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));
+   int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));
+   int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));
+   int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));
+   int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));
+   int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));
+   int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));
+   int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));
+   int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));
+   int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));
+
+#define dct_long_mul(out, inq, coeff) \
+   int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \
+   int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)
+
+#define dct_long_mac(out, acc, inq, coeff) \
+   int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \
+   int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)
+
+#define dct_widen(out, inq) \
+   int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \
+   int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
+
+// wide add
+#define dct_wadd(out, a, b) \
+   int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \
+   int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
+
+// wide sub
+#define dct_wsub(out, a, b) \
+   int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \
+   int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
+
+// butterfly a/b, then shift using "shiftop" by "s" and pack
+#define dct_bfly32o(out0,out1, a,b,shiftop,s) \
+   { \
+      dct_wadd(sum, a, b); \
+      dct_wsub(dif, a, b); \
+      out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \
+      out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \
+   }
+
+#define dct_pass(shiftop, shift) \
+   { \
+      /* even part */ \
+      int16x8_t sum26 = vaddq_s16(row2, row6); \
+      dct_long_mul(p1e, sum26, rot0_0); \
+      dct_long_mac(t2e, p1e, row6, rot0_1); \
+      dct_long_mac(t3e, p1e, row2, rot0_2); \
+      int16x8_t sum04 = vaddq_s16(row0, row4); \
+      int16x8_t dif04 = vsubq_s16(row0, row4); \
+      dct_widen(t0e, sum04); \
+      dct_widen(t1e, dif04); \
+      dct_wadd(x0, t0e, t3e); \
+      dct_wsub(x3, t0e, t3e); \
+      dct_wadd(x1, t1e, t2e); \
+      dct_wsub(x2, t1e, t2e); \
+      /* odd part */ \
+      int16x8_t sum15 = vaddq_s16(row1, row5); \
+      int16x8_t sum17 = vaddq_s16(row1, row7); \
+      int16x8_t sum35 = vaddq_s16(row3, row5); \
+      int16x8_t sum37 = vaddq_s16(row3, row7); \
+      int16x8_t sumodd = vaddq_s16(sum17, sum35); \
+      dct_long_mul(p5o, sumodd, rot1_0); \
+      dct_long_mac(p1o, p5o, sum17, rot1_1); \
+      dct_long_mac(p2o, p5o, sum35, rot1_2); \
+      dct_long_mul(p3o, sum37, rot2_0); \
+      dct_long_mul(p4o, sum15, rot2_1); \
+      dct_wadd(sump13o, p1o, p3o); \
+      dct_wadd(sump24o, p2o, p4o); \
+      dct_wadd(sump23o, p2o, p3o); \
+      dct_wadd(sump14o, p1o, p4o); \
+      dct_long_mac(x4, sump13o, row7, rot3_0); \
+      dct_long_mac(x5, sump24o, row5, rot3_1); \
+      dct_long_mac(x6, sump23o, row3, rot3_2); \
+      dct_long_mac(x7, sump14o, row1, rot3_3); \
+      dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \
+      dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \
+      dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \
+      dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \
+   }
+
+   // load
+   row0 = vld1q_s16(data + 0*8);
+   row1 = vld1q_s16(data + 1*8);
+   row2 = vld1q_s16(data + 2*8);
+   row3 = vld1q_s16(data + 3*8);
+   row4 = vld1q_s16(data + 4*8);
+   row5 = vld1q_s16(data + 5*8);
+   row6 = vld1q_s16(data + 6*8);
+   row7 = vld1q_s16(data + 7*8);
+
+   // add DC bias
+   row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
+
+   // column pass
+   dct_pass(vrshrn_n_s32, 10);
+
+   // 16bit 8x8 transpose
+   {
+// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.
+// whether compilers actually get this is another story, sadly.
+#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }
+#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }
+#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }
+
+      // pass 1
+      dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6
+      dct_trn16(row2, row3);
+      dct_trn16(row4, row5);
+      dct_trn16(row6, row7);
+
+      // pass 2
+      dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4
+      dct_trn32(row1, row3);
+      dct_trn32(row4, row6);
+      dct_trn32(row5, row7);
+
+      // pass 3
+      dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0
+      dct_trn64(row1, row5);
+      dct_trn64(row2, row6);
+      dct_trn64(row3, row7);
+
+#undef dct_trn16
+#undef dct_trn32
+#undef dct_trn64
+   }
+
+   // row pass
+   // vrshrn_n_s32 only supports shifts up to 16, we need
+   // 17. so do a non-rounding shift of 16 first then follow
+   // up with a rounding shift by 1.
+   dct_pass(vshrn_n_s32, 16);
+
+   {
+      // pack and round
+      uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
+      uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
+      uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
+      uint8x8_t p3 = vqrshrun_n_s16(row3, 1);
+      uint8x8_t p4 = vqrshrun_n_s16(row4, 1);
+      uint8x8_t p5 = vqrshrun_n_s16(row5, 1);
+      uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
+      uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
+
+      // again, these can translate into one instruction, but often don't.
+#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }
+#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }
+#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }
+
+      // sadly can't use interleaved stores here since we only write
+      // 8 bytes to each scan line!
+
+      // 8x8 8-bit transpose pass 1
+      dct_trn8_8(p0, p1);
+      dct_trn8_8(p2, p3);
+      dct_trn8_8(p4, p5);
+      dct_trn8_8(p6, p7);
+
+      // pass 2
+      dct_trn8_16(p0, p2);
+      dct_trn8_16(p1, p3);
+      dct_trn8_16(p4, p6);
+      dct_trn8_16(p5, p7);
+
+      // pass 3
+      dct_trn8_32(p0, p4);
+      dct_trn8_32(p1, p5);
+      dct_trn8_32(p2, p6);
+      dct_trn8_32(p3, p7);
+
+      // store
+      vst1_u8(out, p0); out += out_stride;
+      vst1_u8(out, p1); out += out_stride;
+      vst1_u8(out, p2); out += out_stride;
+      vst1_u8(out, p3); out += out_stride;
+      vst1_u8(out, p4); out += out_stride;
+      vst1_u8(out, p5); out += out_stride;
+      vst1_u8(out, p6); out += out_stride;
+      vst1_u8(out, p7);
+
+#undef dct_trn8_8
+#undef dct_trn8_16
+#undef dct_trn8_32
+   }
+
+#undef dct_long_mul
+#undef dct_long_mac
+#undef dct_widen
+#undef dct_wadd
+#undef dct_wsub
+#undef dct_bfly32o
+#undef dct_pass
+}
+
+#endif // STBI_NEON
+
+#define STBI__MARKER_none  0xff
+// if there's a pending marker from the entropy stream, return that
+// otherwise, fetch from the stream and get a marker. if there's no
+// marker, return 0xff, which is never a valid marker value
+static stbi_uc stbi__get_marker(stbi__jpeg *j)
+{
+   stbi_uc x;
+   if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
+   x = stbi__get8(j->s);
+   if (x != 0xff) return STBI__MARKER_none;
+   while (x == 0xff)
+      x = stbi__get8(j->s); // consume repeated 0xff fill bytes
+   return x;
+}
+
+// in each scan, we'll have scan_n components, and the order
+// of the components is specified by order[]
+#define STBI__RESTART(x)     ((x) >= 0xd0 && (x) <= 0xd7)
+
+// after a restart interval, stbi__jpeg_reset the entropy decoder and
+// the dc prediction
+static void stbi__jpeg_reset(stbi__jpeg *j)
+{
+   j->code_bits = 0;
+   j->code_buffer = 0;
+   j->nomore = 0;
+   j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0;
+   j->marker = STBI__MARKER_none;
+   j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
+   j->eob_run = 0;
+   // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
+   // since we don't even allow 1<<30 pixels
+}
+
+static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
+{
+   stbi__jpeg_reset(z);
+   if (!z->progressive) {
+      if (z->scan_n == 1) {
+         int i,j;
+         STBI_SIMD_ALIGN(short, data[64]);
+         int n = z->order[0];
+         // non-interleaved data, we just need to process one block at a time,
+         // in trivial scanline order
+         // number of blocks to do just depends on how many actual "pixels" this
+         // component has, independent of interleaved MCU blocking and such
+         int w = (z->img_comp[n].x+7) >> 3;
+         int h = (z->img_comp[n].y+7) >> 3;
+         for (j=0; j < h; ++j) {
+            for (i=0; i < w; ++i) {
+               int ha = z->img_comp[n].ha;
+               if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
+               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
+               // every data block is an MCU, so countdown the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  // if it's NOT a restart, then just bail, so we get corrupt data
+                  // rather than no data
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      } else { // interleaved
+         int i,j,k,x,y;
+         STBI_SIMD_ALIGN(short, data[64]);
+         for (j=0; j < z->img_mcu_y; ++j) {
+            for (i=0; i < z->img_mcu_x; ++i) {
+               // scan an interleaved mcu... process scan_n components in order
+               for (k=0; k < z->scan_n; ++k) {
+                  int n = z->order[k];
+                  // scan out an mcu's worth of this component; that's just determined
+                  // by the basic H and V specified for the component
+                  for (y=0; y < z->img_comp[n].v; ++y) {
+                     for (x=0; x < z->img_comp[n].h; ++x) {
+                        int x2 = (i*z->img_comp[n].h + x)*8;
+                        int y2 = (j*z->img_comp[n].v + y)*8;
+                        int ha = z->img_comp[n].ha;
+                        if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
+                        z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);
+                     }
+                  }
+               }
+               // after all interleaved components, that's an interleaved MCU,
+               // so now count down the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      }
+   } else {
+      if (z->scan_n == 1) {
+         int i,j;
+         int n = z->order[0];
+         // non-interleaved data, we just need to process one block at a time,
+         // in trivial scanline order
+         // number of blocks to do just depends on how many actual "pixels" this
+         // component has, independent of interleaved MCU blocking and such
+         int w = (z->img_comp[n].x+7) >> 3;
+         int h = (z->img_comp[n].y+7) >> 3;
+         for (j=0; j < h; ++j) {
+            for (i=0; i < w; ++i) {
+               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+               if (z->spec_start == 0) {
+                  if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
+                     return 0;
+               } else {
+                  int ha = z->img_comp[n].ha;
+                  if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))
+                     return 0;
+               }
+               // every data block is an MCU, so countdown the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      } else { // interleaved
+         int i,j,k,x,y;
+         for (j=0; j < z->img_mcu_y; ++j) {
+            for (i=0; i < z->img_mcu_x; ++i) {
+               // scan an interleaved mcu... process scan_n components in order
+               for (k=0; k < z->scan_n; ++k) {
+                  int n = z->order[k];
+                  // scan out an mcu's worth of this component; that's just determined
+                  // by the basic H and V specified for the component
+                  for (y=0; y < z->img_comp[n].v; ++y) {
+                     for (x=0; x < z->img_comp[n].h; ++x) {
+                        int x2 = (i*z->img_comp[n].h + x);
+                        int y2 = (j*z->img_comp[n].v + y);
+                        short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);
+                        if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
+                           return 0;
+                     }
+                  }
+               }
+               // after all interleaved components, that's an interleaved MCU,
+               // so now count down the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      }
+   }
+}
+
+static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)
+{
+   int i;
+   for (i=0; i < 64; ++i)
+      data[i] *= dequant[i];
+}
+
+static void stbi__jpeg_finish(stbi__jpeg *z)
+{
+   if (z->progressive) {
+      // dequantize and idct the data
+      int i,j,n;
+      for (n=0; n < z->s->img_n; ++n) {
+         int w = (z->img_comp[n].x+7) >> 3;
+         int h = (z->img_comp[n].y+7) >> 3;
+         for (j=0; j < h; ++j) {
+            for (i=0; i < w; ++i) {
+               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+               stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);
+               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
+            }
+         }
+      }
+   }
+}
+
+static int stbi__process_marker(stbi__jpeg *z, int m)
+{
+   int L;
+   switch (m) {
+      case STBI__MARKER_none: // no marker found
+         return stbi__err("expected marker","Corrupt JPEG");
+
+      case 0xDD: // DRI - specify restart interval
+         if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");
+         z->restart_interval = stbi__get16be(z->s);
+         return 1;
+
+      case 0xDB: // DQT - define quantization table
+         L = stbi__get16be(z->s)-2;
+         while (L > 0) {
+            int q = stbi__get8(z->s);
+            int p = q >> 4, sixteen = (p != 0);
+            int t = q & 15,i;
+            if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG");
+            if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");
+
+            for (i=0; i < 64; ++i)
+               z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));
+            L -= (sixteen ? 129 : 65);
+         }
+         return L==0;
+
+      case 0xC4: // DHT - define huffman table
+         L = stbi__get16be(z->s)-2;
+         while (L > 0) {
+            stbi_uc *v;
+            int sizes[16],i,n=0;
+            int q = stbi__get8(z->s);
+            int tc = q >> 4;
+            int th = q & 15;
+            if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG");
+            for (i=0; i < 16; ++i) {
+               sizes[i] = stbi__get8(z->s);
+               n += sizes[i];
+            }
+            L -= 17;
+            if (tc == 0) {
+               if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;
+               v = z->huff_dc[th].values;
+            } else {
+               if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;
+               v = z->huff_ac[th].values;
+            }
+            for (i=0; i < n; ++i)
+               v[i] = stbi__get8(z->s);
+            if (tc != 0)
+               stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);
+            L -= n;
+         }
+         return L==0;
+   }
+
+   // check for comment block or APP blocks
+   if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
+      L = stbi__get16be(z->s);
+      if (L < 2) {
+         if (m == 0xFE)
+            return stbi__err("bad COM len","Corrupt JPEG");
+         else
+            return stbi__err("bad APP len","Corrupt JPEG");
+      }
+      L -= 2;
+
+      if (m == 0xE0 && L >= 5) { // JFIF APP0 segment
+         static const unsigned char tag[5] = {'J','F','I','F','\0'};
+         int ok = 1;
+         int i;
+         for (i=0; i < 5; ++i)
+            if (stbi__get8(z->s) != tag[i])
+               ok = 0;
+         L -= 5;
+         if (ok)
+            z->jfif = 1;
+      } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment
+         static const unsigned char tag[6] = {'A','d','o','b','e','\0'};
+         int ok = 1;
+         int i;
+         for (i=0; i < 6; ++i)
+            if (stbi__get8(z->s) != tag[i])
+               ok = 0;
+         L -= 6;
+         if (ok) {
+            stbi__get8(z->s); // version
+            stbi__get16be(z->s); // flags0
+            stbi__get16be(z->s); // flags1
+            z->app14_color_transform = stbi__get8(z->s); // color transform
+            L -= 6;
+         }
+      }
+
+      stbi__skip(z->s, L);
+      return 1;
+   }
+
+   return stbi__err("unknown marker","Corrupt JPEG");
+}
+
+// after we see SOS
+static int stbi__process_scan_header(stbi__jpeg *z)
+{
+   int i;
+   int Ls = stbi__get16be(z->s);
+   z->scan_n = stbi__get8(z->s);
+   if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG");
+   if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG");
+   for (i=0; i < z->scan_n; ++i) {
+      int id = stbi__get8(z->s), which;
+      int q = stbi__get8(z->s);
+      for (which = 0; which < z->s->img_n; ++which)
+         if (z->img_comp[which].id == id)
+            break;
+      if (which == z->s->img_n) return 0; // no match
+      z->img_comp[which].hd = q >> 4;   if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");
+      z->img_comp[which].ha = q & 15;   if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");
+      z->order[i] = which;
+   }
+
+   {
+      int aa;
+      z->spec_start = stbi__get8(z->s);
+      z->spec_end   = stbi__get8(z->s); // should be 63, but might be 0
+      aa = stbi__get8(z->s);
+      z->succ_high = (aa >> 4);
+      z->succ_low  = (aa & 15);
+      if (z->progressive) {
+         if (z->spec_start > 63 || z->spec_end > 63  || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)
+            return stbi__err("bad SOS", "Corrupt JPEG");
+      } else {
+         if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG");
+         if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG");
+         z->spec_end = 63;
+      }
+   }
+
+   return 1;
+}
+
+static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)
+{
+   int i;
+   for (i=0; i < ncomp; ++i) {
+      if (z->img_comp[i].raw_data) {
+         STBI_FREE(z->img_comp[i].raw_data);
+         z->img_comp[i].raw_data = NULL;
+         z->img_comp[i].data = NULL;
+      }
+      if (z->img_comp[i].raw_coeff) {
+         STBI_FREE(z->img_comp[i].raw_coeff);
+         z->img_comp[i].raw_coeff = 0;
+         z->img_comp[i].coeff = 0;
+      }
+      if (z->img_comp[i].linebuf) {
+         STBI_FREE(z->img_comp[i].linebuf);
+         z->img_comp[i].linebuf = NULL;
+      }
+   }
+   return why;
+}
+
+static int stbi__process_frame_header(stbi__jpeg *z, int scan)
+{
+   stbi__context *s = z->s;
+   int Lf,p,i,q, h_max=1,v_max=1,c;
+   Lf = stbi__get16be(s);         if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG
+   p  = stbi__get8(s);            if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
+   s->img_y = stbi__get16be(s);   if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
+   s->img_x = stbi__get16be(s);   if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires
+   c = stbi__get8(s);
+   if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG");
+   s->img_n = c;
+   for (i=0; i < c; ++i) {
+      z->img_comp[i].data = NULL;
+      z->img_comp[i].linebuf = NULL;
+   }
+
+   if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG");
+
+   z->rgb = 0;
+   for (i=0; i < s->img_n; ++i) {
+      static const unsigned char rgb[3] = { 'R', 'G', 'B' };
+      z->img_comp[i].id = stbi__get8(s);
+      if (s->img_n == 3 && z->img_comp[i].id == rgb[i])
+         ++z->rgb;
+      q = stbi__get8(s);
+      z->img_comp[i].h = (q >> 4);  if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG");
+      z->img_comp[i].v = q & 15;    if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG");
+      z->img_comp[i].tq = stbi__get8(s);  if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG");
+   }
+
+   if (scan != STBI__SCAN_load) return 1;
+
+   if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode");
+
+   for (i=0; i < s->img_n; ++i) {
+      if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
+      if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
+   }
+
+   // compute interleaved mcu info
+   z->img_h_max = h_max;
+   z->img_v_max = v_max;
+   z->img_mcu_w = h_max * 8;
+   z->img_mcu_h = v_max * 8;
+   // these sizes can't be more than 17 bits
+   z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
+   z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
+
+   for (i=0; i < s->img_n; ++i) {
+      // number of effective pixels (e.g. for non-interleaved MCU)
+      z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
+      z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
+      // to simplify generation, we'll allocate enough memory to decode
+      // the bogus oversized data from using interleaved MCUs and their
+      // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
+      // discard the extra data until colorspace conversion
+      //
+      // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier)
+      // so these muls can't overflow with 32-bit ints (which we require)
+      z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
+      z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
+      z->img_comp[i].coeff = 0;
+      z->img_comp[i].raw_coeff = 0;
+      z->img_comp[i].linebuf = NULL;
+      z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);
+      if (z->img_comp[i].raw_data == NULL)
+         return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
+      // align blocks for idct using mmx/sse
+      z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
+      if (z->progressive) {
+         // w2, h2 are multiples of 8 (see above)
+         z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;
+         z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;
+         z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15);
+         if (z->img_comp[i].raw_coeff == NULL)
+            return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
+         z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15);
+      }
+   }
+
+   return 1;
+}
+
+// use comparisons since in some cases we handle more than one case (e.g. SOF)
+#define stbi__DNL(x)         ((x) == 0xdc)
+#define stbi__SOI(x)         ((x) == 0xd8)
+#define stbi__EOI(x)         ((x) == 0xd9)
+#define stbi__SOF(x)         ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
+#define stbi__SOS(x)         ((x) == 0xda)
+
+#define stbi__SOF_progressive(x)   ((x) == 0xc2)
+
+static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
+{
+   int m;
+   z->jfif = 0;
+   z->app14_color_transform = -1; // valid values are 0,1,2
+   z->marker = STBI__MARKER_none; // initialize cached marker to empty
+   m = stbi__get_marker(z);
+   if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");
+   if (scan == STBI__SCAN_type) return 1;
+   m = stbi__get_marker(z);
+   while (!stbi__SOF(m)) {
+      if (!stbi__process_marker(z,m)) return 0;
+      m = stbi__get_marker(z);
+      while (m == STBI__MARKER_none) {
+         // some files have extra padding after their blocks, so ok, we'll scan
+         if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");
+         m = stbi__get_marker(z);
+      }
+   }
+   z->progressive = stbi__SOF_progressive(m);
+   if (!stbi__process_frame_header(z, scan)) return 0;
+   return 1;
+}
+
+// decode image to YCbCr format
+static int stbi__decode_jpeg_image(stbi__jpeg *j)
+{
+   int m;
+   for (m = 0; m < 4; m++) {
+      j->img_comp[m].raw_data = NULL;
+      j->img_comp[m].raw_coeff = NULL;
+   }
+   j->restart_interval = 0;
+   if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;
+   m = stbi__get_marker(j);
+   while (!stbi__EOI(m)) {
+      if (stbi__SOS(m)) {
+         if (!stbi__process_scan_header(j)) return 0;
+         if (!stbi__parse_entropy_coded_data(j)) return 0;
+         if (j->marker == STBI__MARKER_none ) {
+            // handle 0s at the end of image data from IP Kamera 9060
+            while (!stbi__at_eof(j->s)) {
+               int x = stbi__get8(j->s);
+               if (x == 255) {
+                  j->marker = stbi__get8(j->s);
+                  break;
+               }
+            }
+            // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
+         }
+      } else if (stbi__DNL(m)) {
+         int Ld = stbi__get16be(j->s);
+         stbi__uint32 NL = stbi__get16be(j->s);
+         if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");
+         if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG");
+      } else {
+         if (!stbi__process_marker(j, m)) return 0;
+      }
+      m = stbi__get_marker(j);
+   }
+   if (j->progressive)
+      stbi__jpeg_finish(j);
+   return 1;
+}
+
+// static jfif-centered resampling (across block boundaries)
+
+typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,
+                                    int w, int hs);
+
+#define stbi__div4(x) ((stbi_uc) ((x) >> 2))
+
+static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   STBI_NOTUSED(out);
+   STBI_NOTUSED(in_far);
+   STBI_NOTUSED(w);
+   STBI_NOTUSED(hs);
+   return in_near;
+}
+
+static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate two samples vertically for every one in input
+   int i;
+   STBI_NOTUSED(hs);
+   for (i=0; i < w; ++i)
+      out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
+   return out;
+}
+
+static stbi_uc*  stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate two samples horizontally for every one in input
+   int i;
+   stbi_uc *input = in_near;
+
+   if (w == 1) {
+      // if only one sample, can't do any interpolation
+      out[0] = out[1] = input[0];
+      return out;
+   }
+
+   out[0] = input[0];
+   out[1] = stbi__div4(input[0]*3 + input[1] + 2);
+   for (i=1; i < w-1; ++i) {
+      int n = 3*input[i]+2;
+      out[i*2+0] = stbi__div4(n+input[i-1]);
+      out[i*2+1] = stbi__div4(n+input[i+1]);
+   }
+   out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);
+   out[i*2+1] = input[w-1];
+
+   STBI_NOTUSED(in_far);
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+
+#define stbi__div16(x) ((stbi_uc) ((x) >> 4))
+
+static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate 2x2 samples for every one in input
+   int i,t0,t1;
+   if (w == 1) {
+      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
+      return out;
+   }
+
+   t1 = 3*in_near[0] + in_far[0];
+   out[0] = stbi__div4(t1+2);
+   for (i=1; i < w; ++i) {
+      t0 = t1;
+      t1 = 3*in_near[i]+in_far[i];
+      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
+      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);
+   }
+   out[w*2-1] = stbi__div4(t1+2);
+
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+
+#if defined(STBI_SSE2) || defined(STBI_NEON)
+static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate 2x2 samples for every one in input
+   int i=0,t0,t1;
+
+   if (w == 1) {
+      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
+      return out;
+   }
+
+   t1 = 3*in_near[0] + in_far[0];
+   // process groups of 8 pixels for as long as we can.
+   // note we can't handle the last pixel in a row in this loop
+   // because we need to handle the filter boundary conditions.
+   for (; i < ((w-1) & ~7); i += 8) {
+#if defined(STBI_SSE2)
+      // load and perform the vertical filtering pass
+      // this uses 3*x + y = 4*x + (y - x)
+      __m128i zero  = _mm_setzero_si128();
+      __m128i farb  = _mm_loadl_epi64((__m128i *) (in_far + i));
+      __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
+      __m128i farw  = _mm_unpacklo_epi8(farb, zero);
+      __m128i nearw = _mm_unpacklo_epi8(nearb, zero);
+      __m128i diff  = _mm_sub_epi16(farw, nearw);
+      __m128i nears = _mm_slli_epi16(nearw, 2);
+      __m128i curr  = _mm_add_epi16(nears, diff); // current row
+
+      // horizontal filter works the same based on shifted vers of current
+      // row. "prev" is current row shifted right by 1 pixel; we need to
+      // insert the previous pixel value (from t1).
+      // "next" is current row shifted left by 1 pixel, with first pixel
+      // of next block of 8 pixels added in.
+      __m128i prv0 = _mm_slli_si128(curr, 2);
+      __m128i nxt0 = _mm_srli_si128(curr, 2);
+      __m128i prev = _mm_insert_epi16(prv0, t1, 0);
+      __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
+
+      // horizontal filter, polyphase implementation since it's convenient:
+      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
+      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
+      // note the shared term.
+      __m128i bias  = _mm_set1_epi16(8);
+      __m128i curs = _mm_slli_epi16(curr, 2);
+      __m128i prvd = _mm_sub_epi16(prev, curr);
+      __m128i nxtd = _mm_sub_epi16(next, curr);
+      __m128i curb = _mm_add_epi16(curs, bias);
+      __m128i even = _mm_add_epi16(prvd, curb);
+      __m128i odd  = _mm_add_epi16(nxtd, curb);
+
+      // interleave even and odd pixels, then undo scaling.
+      __m128i int0 = _mm_unpacklo_epi16(even, odd);
+      __m128i int1 = _mm_unpackhi_epi16(even, odd);
+      __m128i de0  = _mm_srli_epi16(int0, 4);
+      __m128i de1  = _mm_srli_epi16(int1, 4);
+
+      // pack and write output
+      __m128i outv = _mm_packus_epi16(de0, de1);
+      _mm_storeu_si128((__m128i *) (out + i*2), outv);
+#elif defined(STBI_NEON)
+      // load and perform the vertical filtering pass
+      // this uses 3*x + y = 4*x + (y - x)
+      uint8x8_t farb  = vld1_u8(in_far + i);
+      uint8x8_t nearb = vld1_u8(in_near + i);
+      int16x8_t diff  = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
+      int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
+      int16x8_t curr  = vaddq_s16(nears, diff); // current row
+
+      // horizontal filter works the same based on shifted vers of current
+      // row. "prev" is current row shifted right by 1 pixel; we need to
+      // insert the previous pixel value (from t1).
+      // "next" is current row shifted left by 1 pixel, with first pixel
+      // of next block of 8 pixels added in.
+      int16x8_t prv0 = vextq_s16(curr, curr, 7);
+      int16x8_t nxt0 = vextq_s16(curr, curr, 1);
+      int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
+      int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
+
+      // horizontal filter, polyphase implementation since it's convenient:
+      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
+      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
+      // note the shared term.
+      int16x8_t curs = vshlq_n_s16(curr, 2);
+      int16x8_t prvd = vsubq_s16(prev, curr);
+      int16x8_t nxtd = vsubq_s16(next, curr);
+      int16x8_t even = vaddq_s16(curs, prvd);
+      int16x8_t odd  = vaddq_s16(curs, nxtd);
+
+      // undo scaling and round, then store with even/odd phases interleaved
+      uint8x8x2_t o;
+      o.val[0] = vqrshrun_n_s16(even, 4);
+      o.val[1] = vqrshrun_n_s16(odd,  4);
+      vst2_u8(out + i*2, o);
+#endif
+
+      // "previous" value for next iter
+      t1 = 3*in_near[i+7] + in_far[i+7];
+   }
+
+   t0 = t1;
+   t1 = 3*in_near[i] + in_far[i];
+   out[i*2] = stbi__div16(3*t1 + t0 + 8);
+
+   for (++i; i < w; ++i) {
+      t0 = t1;
+      t1 = 3*in_near[i]+in_far[i];
+      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
+      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);
+   }
+   out[w*2-1] = stbi__div4(t1+2);
+
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+#endif
+
+static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // resample with nearest-neighbor
+   int i,j;
+   STBI_NOTUSED(in_far);
+   for (i=0; i < w; ++i)
+      for (j=0; j < hs; ++j)
+         out[i*hs+j] = in_near[i];
+   return out;
+}
+
+// this is a reduced-precision calculation of YCbCr-to-RGB introduced
+// to make sure the code produces the same results in both SIMD and scalar
+#define stbi__float2fixed(x)  (((int) ((x) * 4096.0f + 0.5f)) << 8)
+static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
+{
+   int i;
+   for (i=0; i < count; ++i) {
+      int y_fixed = (y[i] << 20) + (1<<19); // rounding
+      int r,g,b;
+      int cr = pcr[i] - 128;
+      int cb = pcb[i] - 128;
+      r = y_fixed +  cr* stbi__float2fixed(1.40200f);
+      g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
+      b = y_fixed                                     +   cb* stbi__float2fixed(1.77200f);
+      r >>= 20;
+      g >>= 20;
+      b >>= 20;
+      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
+      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
+      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
+      out[0] = (stbi_uc)r;
+      out[1] = (stbi_uc)g;
+      out[2] = (stbi_uc)b;
+      out[3] = 255;
+      out += step;
+   }
+}
+
+#if defined(STBI_SSE2) || defined(STBI_NEON)
+static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)
+{
+   int i = 0;
+
+#ifdef STBI_SSE2
+   // step == 3 is pretty ugly on the final interleave, and i'm not convinced
+   // it's useful in practice (you wouldn't use it for textures, for example).
+   // so just accelerate step == 4 case.
+   if (step == 4) {
+      // this is a fairly straightforward implementation and not super-optimized.
+      __m128i signflip  = _mm_set1_epi8(-0x80);
+      __m128i cr_const0 = _mm_set1_epi16(   (short) ( 1.40200f*4096.0f+0.5f));
+      __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f));
+      __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f));
+      __m128i cb_const1 = _mm_set1_epi16(   (short) ( 1.77200f*4096.0f+0.5f));
+      __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128);
+      __m128i xw = _mm_set1_epi16(255); // alpha channel
+
+      for (; i+7 < count; i += 8) {
+         // load
+         __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));
+         __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));
+         __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));
+         __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128
+         __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128
+
+         // unpack to short (and left-shift cr, cb by 8)
+         __m128i yw  = _mm_unpacklo_epi8(y_bias, y_bytes);
+         __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
+         __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
+
+         // color transform
+         __m128i yws = _mm_srli_epi16(yw, 4);
+         __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
+         __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
+         __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);
+         __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);
+         __m128i rws = _mm_add_epi16(cr0, yws);
+         __m128i gwt = _mm_add_epi16(cb0, yws);
+         __m128i bws = _mm_add_epi16(yws, cb1);
+         __m128i gws = _mm_add_epi16(gwt, cr1);
+
+         // descale
+         __m128i rw = _mm_srai_epi16(rws, 4);
+         __m128i bw = _mm_srai_epi16(bws, 4);
+         __m128i gw = _mm_srai_epi16(gws, 4);
+
+         // back to byte, set up for transpose
+         __m128i brb = _mm_packus_epi16(rw, bw);
+         __m128i gxb = _mm_packus_epi16(gw, xw);
+
+         // transpose to interleave channels
+         __m128i t0 = _mm_unpacklo_epi8(brb, gxb);
+         __m128i t1 = _mm_unpackhi_epi8(brb, gxb);
+         __m128i o0 = _mm_unpacklo_epi16(t0, t1);
+         __m128i o1 = _mm_unpackhi_epi16(t0, t1);
+
+         // store
+         _mm_storeu_si128((__m128i *) (out + 0), o0);
+         _mm_storeu_si128((__m128i *) (out + 16), o1);
+         out += 32;
+      }
+   }
+#endif
+
+#ifdef STBI_NEON
+   // in this version, step=3 support would be easy to add. but is there demand?
+   if (step == 4) {
+      // this is a fairly straightforward implementation and not super-optimized.
+      uint8x8_t signflip = vdup_n_u8(0x80);
+      int16x8_t cr_const0 = vdupq_n_s16(   (short) ( 1.40200f*4096.0f+0.5f));
+      int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f));
+      int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f));
+      int16x8_t cb_const1 = vdupq_n_s16(   (short) ( 1.77200f*4096.0f+0.5f));
+
+      for (; i+7 < count; i += 8) {
+         // load
+         uint8x8_t y_bytes  = vld1_u8(y + i);
+         uint8x8_t cr_bytes = vld1_u8(pcr + i);
+         uint8x8_t cb_bytes = vld1_u8(pcb + i);
+         int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
+         int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
+
+         // expand to s16
+         int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
+         int16x8_t crw = vshll_n_s8(cr_biased, 7);
+         int16x8_t cbw = vshll_n_s8(cb_biased, 7);
+
+         // color transform
+         int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
+         int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
+         int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
+         int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);
+         int16x8_t rws = vaddq_s16(yws, cr0);
+         int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
+         int16x8_t bws = vaddq_s16(yws, cb1);
+
+         // undo scaling, round, convert to byte
+         uint8x8x4_t o;
+         o.val[0] = vqrshrun_n_s16(rws, 4);
+         o.val[1] = vqrshrun_n_s16(gws, 4);
+         o.val[2] = vqrshrun_n_s16(bws, 4);
+         o.val[3] = vdup_n_u8(255);
+
+         // store, interleaving r/g/b/a
+         vst4_u8(out, o);
+         out += 8*4;
+      }
+   }
+#endif
+
+   for (; i < count; ++i) {
+      int y_fixed = (y[i] << 20) + (1<<19); // rounding
+      int r,g,b;
+      int cr = pcr[i] - 128;
+      int cb = pcb[i] - 128;
+      r = y_fixed + cr* stbi__float2fixed(1.40200f);
+      g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
+      b = y_fixed                                   +   cb* stbi__float2fixed(1.77200f);
+      r >>= 20;
+      g >>= 20;
+      b >>= 20;
+      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
+      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
+      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
+      out[0] = (stbi_uc)r;
+      out[1] = (stbi_uc)g;
+      out[2] = (stbi_uc)b;
+      out[3] = 255;
+      out += step;
+   }
+}
+#endif
+
+// set up the kernels
+static void stbi__setup_jpeg(stbi__jpeg *j)
+{
+   j->idct_block_kernel = stbi__idct_block;
+   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
+   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
+
+#ifdef STBI_SSE2
+   if (stbi__sse2_available()) {
+      j->idct_block_kernel = stbi__idct_simd;
+      j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
+      j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+   }
+#endif
+
+#ifdef STBI_NEON
+   j->idct_block_kernel = stbi__idct_simd;
+   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
+   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+#endif
+}
+
+// clean up the temporary component buffers
+static void stbi__cleanup_jpeg(stbi__jpeg *j)
+{
+   stbi__free_jpeg_components(j, j->s->img_n, 0);
+}
+
+typedef struct
+{
+   resample_row_func resample;
+   stbi_uc *line0,*line1;
+   int hs,vs;   // expansion factor in each axis
+   int w_lores; // horizontal pixels pre-expansion
+   int ystep;   // how far through vertical expansion we are
+   int ypos;    // which pre-expansion row we're on
+} stbi__resample;
+
+// fast 0..255 * 0..255 => 0..255 rounded multiplication
+static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)
+{
+   unsigned int t = x*y + 128;
+   return (stbi_uc) ((t + (t >>8)) >> 8);
+}
+
+static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
+{
+   int n, decode_n, is_rgb;
+   z->s->img_n = 0; // make stbi__cleanup_jpeg safe
+
+   // validate req_comp
+   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
+
+   // load a jpeg image from whichever source, but leave in YCbCr format
+   if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }
+
+   // determine actual number of components to generate
+   n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;
+
+   is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));
+
+   if (z->s->img_n == 3 && n < 3 && !is_rgb)
+      decode_n = 1;
+   else
+      decode_n = z->s->img_n;
+
+   // resample and color-convert
+   {
+      int k;
+      unsigned int i,j;
+      stbi_uc *output;
+      stbi_uc *coutput[4];
+
+      stbi__resample res_comp[4];
+
+      for (k=0; k < decode_n; ++k) {
+         stbi__resample *r = &res_comp[k];
+
+         // allocate line buffer big enough for upsampling off the edges
+         // with upsample factor of 4
+         z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3);
+         if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
+
+         r->hs      = z->img_h_max / z->img_comp[k].h;
+         r->vs      = z->img_v_max / z->img_comp[k].v;
+         r->ystep   = r->vs >> 1;
+         r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
+         r->ypos    = 0;
+         r->line0   = r->line1 = z->img_comp[k].data;
+
+         if      (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
+         else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;
+         else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;
+         else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;
+         else                               r->resample = stbi__resample_row_generic;
+      }
+
+      // can't error after this so, this is safe
+      output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
+      if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
+
+      // now go ahead and resample
+      for (j=0; j < z->s->img_y; ++j) {
+         stbi_uc *out = output + n * z->s->img_x * j;
+         for (k=0; k < decode_n; ++k) {
+            stbi__resample *r = &res_comp[k];
+            int y_bot = r->ystep >= (r->vs >> 1);
+            coutput[k] = r->resample(z->img_comp[k].linebuf,
+                                     y_bot ? r->line1 : r->line0,
+                                     y_bot ? r->line0 : r->line1,
+                                     r->w_lores, r->hs);
+            if (++r->ystep >= r->vs) {
+               r->ystep = 0;
+               r->line0 = r->line1;
+               if (++r->ypos < z->img_comp[k].y)
+                  r->line1 += z->img_comp[k].w2;
+            }
+         }
+         if (n >= 3) {
+            stbi_uc *y = coutput[0];
+            if (z->s->img_n == 3) {
+               if (is_rgb) {
+                  for (i=0; i < z->s->img_x; ++i) {
+                     out[0] = y[i];
+                     out[1] = coutput[1][i];
+                     out[2] = coutput[2][i];
+                     out[3] = 255;
+                     out += n;
+                  }
+               } else {
+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+               }
+            } else if (z->s->img_n == 4) {
+               if (z->app14_color_transform == 0) { // CMYK
+                  for (i=0; i < z->s->img_x; ++i) {
+                     stbi_uc m = coutput[3][i];
+                     out[0] = stbi__blinn_8x8(coutput[0][i], m);
+                     out[1] = stbi__blinn_8x8(coutput[1][i], m);
+                     out[2] = stbi__blinn_8x8(coutput[2][i], m);
+                     out[3] = 255;
+                     out += n;
+                  }
+               } else if (z->app14_color_transform == 2) { // YCCK
+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+                  for (i=0; i < z->s->img_x; ++i) {
+                     stbi_uc m = coutput[3][i];
+                     out[0] = stbi__blinn_8x8(255 - out[0], m);
+                     out[1] = stbi__blinn_8x8(255 - out[1], m);
+                     out[2] = stbi__blinn_8x8(255 - out[2], m);
+                     out += n;
+                  }
+               } else { // YCbCr + alpha?  Ignore the fourth channel for now
+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+               }
+            } else
+               for (i=0; i < z->s->img_x; ++i) {
+                  out[0] = out[1] = out[2] = y[i];
+                  out[3] = 255; // not used if n==3
+                  out += n;
+               }
+         } else {
+            if (is_rgb) {
+               if (n == 1)
+                  for (i=0; i < z->s->img_x; ++i)
+                     *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+               else {
+                  for (i=0; i < z->s->img_x; ++i, out += 2) {
+                     out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+                     out[1] = 255;
+                  }
+               }
+            } else if (z->s->img_n == 4 && z->app14_color_transform == 0) {
+               for (i=0; i < z->s->img_x; ++i) {
+                  stbi_uc m = coutput[3][i];
+                  stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);
+                  stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);
+                  stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);
+                  out[0] = stbi__compute_y(r, g, b);
+                  out[1] = 255;
+                  out += n;
+               }
+            } else if (z->s->img_n == 4 && z->app14_color_transform == 2) {
+               for (i=0; i < z->s->img_x; ++i) {
+                  out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);
+                  out[1] = 255;
+                  out += n;
+               }
+            } else {
+               stbi_uc *y = coutput[0];
+               if (n == 1)
+                  for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
+               else
+                  for (i=0; i < z->s->img_x; ++i) *out++ = y[i], *out++ = 255;
+            }
+         }
+      }
+      stbi__cleanup_jpeg(z);
+      *out_x = z->s->img_x;
+      *out_y = z->s->img_y;
+      if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output
+      return output;
+   }
+}
+
+static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   unsigned char* result;
+   stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));
+   STBI_NOTUSED(ri);
+   j->s = s;
+   stbi__setup_jpeg(j);
+   result = load_jpeg_image(j, x,y,comp,req_comp);
+   STBI_FREE(j);
+   return result;
+}
+
+static int stbi__jpeg_test(stbi__context *s)
+{
+   int r;
+   stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));
+   j->s = s;
+   stbi__setup_jpeg(j);
+   r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
+   stbi__rewind(s);
+   STBI_FREE(j);
+   return r;
+}
+
+static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
+{
+   if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
+      stbi__rewind( j->s );
+      return 0;
+   }
+   if (x) *x = j->s->img_x;
+   if (y) *y = j->s->img_y;
+   if (comp) *comp = j->s->img_n >= 3 ? 3 : 1;
+   return 1;
+}
+
+static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int result;
+   stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg)));
+   j->s = s;
+   result = stbi__jpeg_info_raw(j, x, y, comp);
+   STBI_FREE(j);
+   return result;
+}
+#endif
+
+// public domain zlib decode    v0.2  Sean Barrett 2006-11-18
+//    simple implementation
+//      - all input must be provided in an upfront buffer
+//      - all output is written to a single output buffer (can malloc/realloc)
+//    performance
+//      - fast huffman
+
+#ifndef STBI_NO_ZLIB
+
+// fast-way is faster to check than jpeg huffman, but slow way is slower
+#define STBI__ZFAST_BITS  9 // accelerate all cases in default tables
+#define STBI__ZFAST_MASK  ((1 << STBI__ZFAST_BITS) - 1)
+
+// zlib-style huffman encoding
+// (jpegs packs from left, zlib from right, so can't share code)
+typedef struct
+{
+   stbi__uint16 fast[1 << STBI__ZFAST_BITS];
+   stbi__uint16 firstcode[16];
+   int maxcode[17];
+   stbi__uint16 firstsymbol[16];
+   stbi_uc  size[288];
+   stbi__uint16 value[288];
+} stbi__zhuffman;
+
+stbi_inline static int stbi__bitreverse16(int n)
+{
+  n = ((n & 0xAAAA) >>  1) | ((n & 0x5555) << 1);
+  n = ((n & 0xCCCC) >>  2) | ((n & 0x3333) << 2);
+  n = ((n & 0xF0F0) >>  4) | ((n & 0x0F0F) << 4);
+  n = ((n & 0xFF00) >>  8) | ((n & 0x00FF) << 8);
+  return n;
+}
+
+stbi_inline static int stbi__bit_reverse(int v, int bits)
+{
+   STBI_ASSERT(bits <= 16);
+   // to bit reverse n bits, reverse 16 and shift
+   // e.g. 11 bits, bit reverse and shift away 5
+   return stbi__bitreverse16(v) >> (16-bits);
+}
+
+static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)
+{
+   int i,k=0;
+   int code, next_code[16], sizes[17];
+
+   // DEFLATE spec for generating codes
+   memset(sizes, 0, sizeof(sizes));
+   memset(z->fast, 0, sizeof(z->fast));
+   for (i=0; i < num; ++i)
+      ++sizes[sizelist[i]];
+   sizes[0] = 0;
+   for (i=1; i < 16; ++i)
+      if (sizes[i] > (1 << i))
+         return stbi__err("bad sizes", "Corrupt PNG");
+   code = 0;
+   for (i=1; i < 16; ++i) {
+      next_code[i] = code;
+      z->firstcode[i] = (stbi__uint16) code;
+      z->firstsymbol[i] = (stbi__uint16) k;
+      code = (code + sizes[i]);
+      if (sizes[i])
+         if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG");
+      z->maxcode[i] = code << (16-i); // preshift for inner loop
+      code <<= 1;
+      k += sizes[i];
+   }
+   z->maxcode[16] = 0x10000; // sentinel
+   for (i=0; i < num; ++i) {
+      int s = sizelist[i];
+      if (s) {
+         int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
+         stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);
+         z->size [c] = (stbi_uc     ) s;
+         z->value[c] = (stbi__uint16) i;
+         if (s <= STBI__ZFAST_BITS) {
+            int j = stbi__bit_reverse(next_code[s],s);
+            while (j < (1 << STBI__ZFAST_BITS)) {
+               z->fast[j] = fastv;
+               j += (1 << s);
+            }
+         }
+         ++next_code[s];
+      }
+   }
+   return 1;
+}
+
+// zlib-from-memory implementation for PNG reading
+//    because PNG allows splitting the zlib stream arbitrarily,
+//    and it's annoying structurally to have PNG call ZLIB call PNG,
+//    we require PNG read all the IDATs and combine them into a single
+//    memory buffer
+
+typedef struct
+{
+   stbi_uc *zbuffer, *zbuffer_end;
+   int num_bits;
+   stbi__uint32 code_buffer;
+
+   char *zout;
+   char *zout_start;
+   char *zout_end;
+   int   z_expandable;
+
+   stbi__zhuffman z_length, z_distance;
+} stbi__zbuf;
+
+stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)
+{
+   if (z->zbuffer >= z->zbuffer_end) return 0;
+   return *z->zbuffer++;
+}
+
+static void stbi__fill_bits(stbi__zbuf *z)
+{
+   do {
+      STBI_ASSERT(z->code_buffer < (1U << z->num_bits));
+      z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
+      z->num_bits += 8;
+   } while (z->num_bits <= 24);
+}
+
+stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
+{
+   unsigned int k;
+   if (z->num_bits < n) stbi__fill_bits(z);
+   k = z->code_buffer & ((1 << n) - 1);
+   z->code_buffer >>= n;
+   z->num_bits -= n;
+   return k;
+}
+
+static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
+{
+   int b,s,k;
+   // not resolved by fast table, so compute it the slow way
+   // use jpeg approach, which requires MSbits at top
+   k = stbi__bit_reverse(a->code_buffer, 16);
+   for (s=STBI__ZFAST_BITS+1; ; ++s)
+      if (k < z->maxcode[s])
+         break;
+   if (s == 16) return -1; // invalid code!
+   // code size is s, so:
+   b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
+   STBI_ASSERT(z->size[b] == s);
+   a->code_buffer >>= s;
+   a->num_bits -= s;
+   return z->value[b];
+}
+
+stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
+{
+   int b,s;
+   if (a->num_bits < 16) stbi__fill_bits(a);
+   b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
+   if (b) {
+      s = b >> 9;
+      a->code_buffer >>= s;
+      a->num_bits -= s;
+      return b & 511;
+   }
+   return stbi__zhuffman_decode_slowpath(a, z);
+}
+
+static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to make room for n bytes
+{
+   char *q;
+   int cur, limit, old_limit;
+   z->zout = zout;
+   if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
+   cur   = (int) (z->zout     - z->zout_start);
+   limit = old_limit = (int) (z->zout_end - z->zout_start);
+   while (cur + n > limit)
+      limit *= 2;
+   q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
+   STBI_NOTUSED(old_limit);
+   if (q == NULL) return stbi__err("outofmem", "Out of memory");
+   z->zout_start = q;
+   z->zout       = q + cur;
+   z->zout_end   = q + limit;
+   return 1;
+}
+
+static const int stbi__zlength_base[31] = {
+   3,4,5,6,7,8,9,10,11,13,
+   15,17,19,23,27,31,35,43,51,59,
+   67,83,99,115,131,163,195,227,258,0,0 };
+
+static const int stbi__zlength_extra[31]=
+{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
+
+static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
+257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
+
+static const int stbi__zdist_extra[32] =
+{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
+
+static int stbi__parse_huffman_block(stbi__zbuf *a)
+{
+   char *zout = a->zout;
+   for(;;) {
+      int z = stbi__zhuffman_decode(a, &a->z_length);
+      if (z < 256) {
+         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes
+         if (zout >= a->zout_end) {
+            if (!stbi__zexpand(a, zout, 1)) return 0;
+            zout = a->zout;
+         }
+         *zout++ = (char) z;
+      } else {
+         stbi_uc *p;
+         int len,dist;
+         if (z == 256) {
+            a->zout = zout;
+            return 1;
+         }
+         z -= 257;
+         len = stbi__zlength_base[z];
+         if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
+         z = stbi__zhuffman_decode(a, &a->z_distance);
+         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG");
+         dist = stbi__zdist_base[z];
+         if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
+         if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
+         if (zout + len > a->zout_end) {
+            if (!stbi__zexpand(a, zout, len)) return 0;
+            zout = a->zout;
+         }
+         p = (stbi_uc *) (zout - dist);
+         if (dist == 1) { // run of one byte; common in images.
+            stbi_uc v = *p;
+            if (len) { do *zout++ = v; while (--len); }
+         } else {
+            if (len) { do *zout++ = *p++; while (--len); }
+         }
+      }
+   }
+}
+
+static int stbi__compute_huffman_codes(stbi__zbuf *a)
+{
+   static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
+   stbi__zhuffman z_codelength;
+   stbi_uc lencodes[286+32+137];//padding for maximum single op
+   stbi_uc codelength_sizes[19];
+   int i,n;
+
+   int hlit  = stbi__zreceive(a,5) + 257;
+   int hdist = stbi__zreceive(a,5) + 1;
+   int hclen = stbi__zreceive(a,4) + 4;
+   int ntot  = hlit + hdist;
+
+   memset(codelength_sizes, 0, sizeof(codelength_sizes));
+   for (i=0; i < hclen; ++i) {
+      int s = stbi__zreceive(a,3);
+      codelength_sizes[length_dezigzag[i]] = (stbi_uc) s;
+   }
+   if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
+
+   n = 0;
+   while (n < ntot) {
+      int c = stbi__zhuffman_decode(a, &z_codelength);
+      if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG");
+      if (c < 16)
+         lencodes[n++] = (stbi_uc) c;
+      else {
+         stbi_uc fill = 0;
+         if (c == 16) {
+            c = stbi__zreceive(a,2)+3;
+            if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG");
+            fill = lencodes[n-1];
+         } else if (c == 17)
+            c = stbi__zreceive(a,3)+3;
+         else {
+            STBI_ASSERT(c == 18);
+            c = stbi__zreceive(a,7)+11;
+         }
+         if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG");
+         memset(lencodes+n, fill, c);
+         n += c;
+      }
+   }
+   if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG");
+   if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
+   if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
+   return 1;
+}
+
+static int stbi__parse_uncompressed_block(stbi__zbuf *a)
+{
+   stbi_uc header[4];
+   int len,nlen,k;
+   if (a->num_bits & 7)
+      stbi__zreceive(a, a->num_bits & 7); // discard
+   // drain the bit-packed data into header
+   k = 0;
+   while (a->num_bits > 0) {
+      header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check
+      a->code_buffer >>= 8;
+      a->num_bits -= 8;
+   }
+   STBI_ASSERT(a->num_bits == 0);
+   // now fill header the normal way
+   while (k < 4)
+      header[k++] = stbi__zget8(a);
+   len  = header[1] * 256 + header[0];
+   nlen = header[3] * 256 + header[2];
+   if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG");
+   if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG");
+   if (a->zout + len > a->zout_end)
+      if (!stbi__zexpand(a, a->zout, len)) return 0;
+   memcpy(a->zout, a->zbuffer, len);
+   a->zbuffer += len;
+   a->zout += len;
+   return 1;
+}
+
+static int stbi__parse_zlib_header(stbi__zbuf *a)
+{
+   int cmf   = stbi__zget8(a);
+   int cm    = cmf & 15;
+   /* int cinfo = cmf >> 4; */
+   int flg   = stbi__zget8(a);
+   if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
+   if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
+   if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
+   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
+   return 1;
+}
+
+static const stbi_uc stbi__zdefault_length[288] =
+{
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8
+};
+static const stbi_uc stbi__zdefault_distance[32] =
+{
+   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
+};
+/*
+Init algorithm:
+{
+   int i;   // use <= to match clearly with spec
+   for (i=0; i <= 143; ++i)     stbi__zdefault_length[i]   = 8;
+   for (   ; i <= 255; ++i)     stbi__zdefault_length[i]   = 9;
+   for (   ; i <= 279; ++i)     stbi__zdefault_length[i]   = 7;
+   for (   ; i <= 287; ++i)     stbi__zdefault_length[i]   = 8;
+
+   for (i=0; i <=  31; ++i)     stbi__zdefault_distance[i] = 5;
+}
+*/
+
+static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
+{
+   int final, type;
+   if (parse_header)
+      if (!stbi__parse_zlib_header(a)) return 0;
+   a->num_bits = 0;
+   a->code_buffer = 0;
+   do {
+      final = stbi__zreceive(a,1);
+      type = stbi__zreceive(a,2);
+      if (type == 0) {
+         if (!stbi__parse_uncompressed_block(a)) return 0;
+      } else if (type == 3) {
+         return 0;
+      } else {
+         if (type == 1) {
+            // use fixed code lengths
+            if (!stbi__zbuild_huffman(&a->z_length  , stbi__zdefault_length  , 288)) return 0;
+            if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance,  32)) return 0;
+         } else {
+            if (!stbi__compute_huffman_codes(a)) return 0;
+         }
+         if (!stbi__parse_huffman_block(a)) return 0;
+      }
+   } while (!final);
+   return 1;
+}
+
+static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
+{
+   a->zout_start = obuf;
+   a->zout       = obuf;
+   a->zout_end   = obuf + olen;
+   a->z_expandable = exp;
+
+   return stbi__parse_zlib(a, parse_header);
+}
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
+{
+   stbi__zbuf a;
+   char *p = (char *) stbi__malloc(initial_size);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi_uc *) buffer;
+   a.zbuffer_end = (stbi_uc *) buffer + len;
+   if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      STBI_FREE(a.zout_start);
+      return NULL;
+   }
+}
+
+STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
+{
+   return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
+}
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
+{
+   stbi__zbuf a;
+   char *p = (char *) stbi__malloc(initial_size);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi_uc *) buffer;
+   a.zbuffer_end = (stbi_uc *) buffer + len;
+   if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      STBI_FREE(a.zout_start);
+      return NULL;
+   }
+}
+
+STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
+{
+   stbi__zbuf a;
+   a.zbuffer = (stbi_uc *) ibuffer;
+   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
+   if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
+      return (int) (a.zout - a.zout_start);
+   else
+      return -1;
+}
+
+STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
+{
+   stbi__zbuf a;
+   char *p = (char *) stbi__malloc(16384);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi_uc *) buffer;
+   a.zbuffer_end = (stbi_uc *) buffer+len;
+   if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      STBI_FREE(a.zout_start);
+      return NULL;
+   }
+}
+
+STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
+{
+   stbi__zbuf a;
+   a.zbuffer = (stbi_uc *) ibuffer;
+   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
+   if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
+      return (int) (a.zout - a.zout_start);
+   else
+      return -1;
+}
+#endif
+
+// public domain "baseline" PNG decoder   v0.10  Sean Barrett 2006-11-18
+//    simple implementation
+//      - only 8-bit samples
+//      - no CRC checking
+//      - allocates lots of intermediate memory
+//        - avoids problem of streaming data between subsystems
+//        - avoids explicit window management
+//    performance
+//      - uses stb_zlib, a PD zlib implementation with fast huffman decoding
+
+#ifndef STBI_NO_PNG
+typedef struct
+{
+   stbi__uint32 length;
+   stbi__uint32 type;
+} stbi__pngchunk;
+
+static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)
+{
+   stbi__pngchunk c;
+   c.length = stbi__get32be(s);
+   c.type   = stbi__get32be(s);
+   return c;
+}
+
+static int stbi__check_png_header(stbi__context *s)
+{
+   static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
+   int i;
+   for (i=0; i < 8; ++i)
+      if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
+   return 1;
+}
+
+typedef struct
+{
+   stbi__context *s;
+   stbi_uc *idata, *expanded, *out;
+   int depth;
+} stbi__png;
+
+
+enum {
+   STBI__F_none=0,
+   STBI__F_sub=1,
+   STBI__F_up=2,
+   STBI__F_avg=3,
+   STBI__F_paeth=4,
+   // synthetic filters used for first scanline to avoid needing a dummy row of 0s
+   STBI__F_avg_first,
+   STBI__F_paeth_first
+};
+
+static stbi_uc first_row_filter[5] =
+{
+   STBI__F_none,
+   STBI__F_sub,
+   STBI__F_none,
+   STBI__F_avg_first,
+   STBI__F_paeth_first
+};
+
+static int stbi__paeth(int a, int b, int c)
+{
+   int p = a + b - c;
+   int pa = abs(p-a);
+   int pb = abs(p-b);
+   int pc = abs(p-c);
+   if (pa <= pb && pa <= pc) return a;
+   if (pb <= pc) return b;
+   return c;
+}
+
+static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
+
+// create the png data from post-deflated data
+static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)
+{
+   int bytes = (depth == 16? 2 : 1);
+   stbi__context *s = a->s;
+   stbi__uint32 i,j,stride = x*out_n*bytes;
+   stbi__uint32 img_len, img_width_bytes;
+   int k;
+   int img_n = s->img_n; // copy it into a local for later
+
+   int output_bytes = out_n*bytes;
+   int filter_bytes = img_n*bytes;
+   int width = x;
+
+   STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
+   a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into
+   if (!a->out) return stbi__err("outofmem", "Out of memory");
+
+   if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG");
+   img_width_bytes = (((img_n * x * depth) + 7) >> 3);
+   img_len = (img_width_bytes + 1) * y;
+
+   // we used to check for exact match between raw_len and img_len on non-interlaced PNGs,
+   // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros),
+   // so just check for raw_len < img_len always.
+   if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG");
+
+   for (j=0; j < y; ++j) {
+      stbi_uc *cur = a->out + stride*j;
+      stbi_uc *prior;
+      int filter = *raw++;
+
+      if (filter > 4)
+         return stbi__err("invalid filter","Corrupt PNG");
+
+      if (depth < 8) {
+         STBI_ASSERT(img_width_bytes <= x);
+         cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place
+         filter_bytes = 1;
+         width = img_width_bytes;
+      }
+      prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above
+
+      // if first row, use special filter that doesn't sample previous row
+      if (j == 0) filter = first_row_filter[filter];
+
+      // handle first byte explicitly
+      for (k=0; k < filter_bytes; ++k) {
+         switch (filter) {
+            case STBI__F_none       : cur[k] = raw[k]; break;
+            case STBI__F_sub        : cur[k] = raw[k]; break;
+            case STBI__F_up         : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
+            case STBI__F_avg        : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break;
+            case STBI__F_paeth      : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break;
+            case STBI__F_avg_first  : cur[k] = raw[k]; break;
+            case STBI__F_paeth_first: cur[k] = raw[k]; break;
+         }
+      }
+
+      if (depth == 8) {
+         if (img_n != out_n)
+            cur[img_n] = 255; // first pixel
+         raw += img_n;
+         cur += out_n;
+         prior += out_n;
+      } else if (depth == 16) {
+         if (img_n != out_n) {
+            cur[filter_bytes]   = 255; // first pixel top byte
+            cur[filter_bytes+1] = 255; // first pixel bottom byte
+         }
+         raw += filter_bytes;
+         cur += output_bytes;
+         prior += output_bytes;
+      } else {
+         raw += 1;
+         cur += 1;
+         prior += 1;
+      }
+
+      // this is a little gross, so that we don't switch per-pixel or per-component
+      if (depth < 8 || img_n == out_n) {
+         int nk = (width - 1)*filter_bytes;
+         #define STBI__CASE(f) \
+             case f:     \
+                for (k=0; k < nk; ++k)
+         switch (filter) {
+            // "none" filter turns into a memcpy here; make that explicit.
+            case STBI__F_none:         memcpy(cur, raw, nk); break;
+            STBI__CASE(STBI__F_sub)          { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break;
+            STBI__CASE(STBI__F_up)           { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
+            STBI__CASE(STBI__F_avg)          { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break;
+            STBI__CASE(STBI__F_paeth)        { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break;
+            STBI__CASE(STBI__F_avg_first)    { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break;
+            STBI__CASE(STBI__F_paeth_first)  { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); } break;
+         }
+         #undef STBI__CASE
+         raw += nk;
+      } else {
+         STBI_ASSERT(img_n+1 == out_n);
+         #define STBI__CASE(f) \
+             case f:     \
+                for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \
+                   for (k=0; k < filter_bytes; ++k)
+         switch (filter) {
+            STBI__CASE(STBI__F_none)         { cur[k] = raw[k]; } break;
+            STBI__CASE(STBI__F_sub)          { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break;
+            STBI__CASE(STBI__F_up)           { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
+            STBI__CASE(STBI__F_avg)          { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break;
+            STBI__CASE(STBI__F_paeth)        { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break;
+            STBI__CASE(STBI__F_avg_first)    { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break;
+            STBI__CASE(STBI__F_paeth_first)  { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); } break;
+         }
+         #undef STBI__CASE
+
+         // the loop above sets the high byte of the pixels' alpha, but for
+         // 16 bit png files we also need the low byte set. we'll do that here.
+         if (depth == 16) {
+            cur = a->out + stride*j; // start at the beginning of the row again
+            for (i=0; i < x; ++i,cur+=output_bytes) {
+               cur[filter_bytes+1] = 255;
+            }
+         }
+      }
+   }
+
+   // we make a separate pass to expand bits to pixels; for performance,
+   // this could run two scanlines behind the above code, so it won't
+   // intefere with filtering but will still be in the cache.
+   if (depth < 8) {
+      for (j=0; j < y; ++j) {
+         stbi_uc *cur = a->out + stride*j;
+         stbi_uc *in  = a->out + stride*j + x*out_n - img_width_bytes;
+         // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit
+         // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop
+         stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range
+
+         // note that the final byte might overshoot and write more data than desired.
+         // we can allocate enough data that this never writes out of memory, but it
+         // could also overwrite the next scanline. can it overwrite non-empty data
+         // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel.
+         // so we need to explicitly clamp the final ones
+
+         if (depth == 4) {
+            for (k=x*img_n; k >= 2; k-=2, ++in) {
+               *cur++ = scale * ((*in >> 4)       );
+               *cur++ = scale * ((*in     ) & 0x0f);
+            }
+            if (k > 0) *cur++ = scale * ((*in >> 4)       );
+         } else if (depth == 2) {
+            for (k=x*img_n; k >= 4; k-=4, ++in) {
+               *cur++ = scale * ((*in >> 6)       );
+               *cur++ = scale * ((*in >> 4) & 0x03);
+               *cur++ = scale * ((*in >> 2) & 0x03);
+               *cur++ = scale * ((*in     ) & 0x03);
+            }
+            if (k > 0) *cur++ = scale * ((*in >> 6)       );
+            if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03);
+            if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03);
+         } else if (depth == 1) {
+            for (k=x*img_n; k >= 8; k-=8, ++in) {
+               *cur++ = scale * ((*in >> 7)       );
+               *cur++ = scale * ((*in >> 6) & 0x01);
+               *cur++ = scale * ((*in >> 5) & 0x01);
+               *cur++ = scale * ((*in >> 4) & 0x01);
+               *cur++ = scale * ((*in >> 3) & 0x01);
+               *cur++ = scale * ((*in >> 2) & 0x01);
+               *cur++ = scale * ((*in >> 1) & 0x01);
+               *cur++ = scale * ((*in     ) & 0x01);
+            }
+            if (k > 0) *cur++ = scale * ((*in >> 7)       );
+            if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01);
+            if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01);
+            if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01);
+            if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01);
+            if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01);
+            if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01);
+         }
+         if (img_n != out_n) {
+            int q;
+            // insert alpha = 255
+            cur = a->out + stride*j;
+            if (img_n == 1) {
+               for (q=x-1; q >= 0; --q) {
+                  cur[q*2+1] = 255;
+                  cur[q*2+0] = cur[q];
+               }
+            } else {
+               STBI_ASSERT(img_n == 3);
+               for (q=x-1; q >= 0; --q) {
+                  cur[q*4+3] = 255;
+                  cur[q*4+2] = cur[q*3+2];
+                  cur[q*4+1] = cur[q*3+1];
+                  cur[q*4+0] = cur[q*3+0];
+               }
+            }
+         }
+      }
+   } else if (depth == 16) {
+      // force the image data from big-endian to platform-native.
+      // this is done in a separate pass due to the decoding relying
+      // on the data being untouched, but could probably be done
+      // per-line during decode if care is taken.
+      stbi_uc *cur = a->out;
+      stbi__uint16 *cur16 = (stbi__uint16*)cur;
+
+      for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) {
+         *cur16 = (cur[0] << 8) | cur[1];
+      }
+   }
+
+   return 1;
+}
+
+static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)
+{
+   int bytes = (depth == 16 ? 2 : 1);
+   int out_bytes = out_n * bytes;
+   stbi_uc *final;
+   int p;
+   if (!interlaced)
+      return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
+
+   // de-interlacing
+   final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
+   for (p=0; p < 7; ++p) {
+      int xorig[] = { 0,4,0,2,0,1,0 };
+      int yorig[] = { 0,0,4,0,2,0,1 };
+      int xspc[]  = { 8,8,4,4,2,2,1 };
+      int yspc[]  = { 8,8,8,4,4,2,2 };
+      int i,j,x,y;
+      // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
+      x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
+      y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
+      if (x && y) {
+         stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
+         if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
+            STBI_FREE(final);
+            return 0;
+         }
+         for (j=0; j < y; ++j) {
+            for (i=0; i < x; ++i) {
+               int out_y = j*yspc[p]+yorig[p];
+               int out_x = i*xspc[p]+xorig[p];
+               memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,
+                      a->out + (j*x+i)*out_bytes, out_bytes);
+            }
+         }
+         STBI_FREE(a->out);
+         image_data += img_len;
+         image_data_len -= img_len;
+      }
+   }
+   a->out = final;
+
+   return 1;
+}
+
+static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
+{
+   stbi__context *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi_uc *p = z->out;
+
+   // compute color-based transparency, assuming we've
+   // already got 255 as the alpha value in the output
+   STBI_ASSERT(out_n == 2 || out_n == 4);
+
+   if (out_n == 2) {
+      for (i=0; i < pixel_count; ++i) {
+         p[1] = (p[0] == tc[0] ? 0 : 255);
+         p += 2;
+      }
+   } else {
+      for (i=0; i < pixel_count; ++i) {
+         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+            p[3] = 0;
+         p += 4;
+      }
+   }
+   return 1;
+}
+
+static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)
+{
+   stbi__context *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi__uint16 *p = (stbi__uint16*) z->out;
+
+   // compute color-based transparency, assuming we've
+   // already got 65535 as the alpha value in the output
+   STBI_ASSERT(out_n == 2 || out_n == 4);
+
+   if (out_n == 2) {
+      for (i = 0; i < pixel_count; ++i) {
+         p[1] = (p[0] == tc[0] ? 0 : 65535);
+         p += 2;
+      }
+   } else {
+      for (i = 0; i < pixel_count; ++i) {
+         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+            p[3] = 0;
+         p += 4;
+      }
+   }
+   return 1;
+}
+
+static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)
+{
+   stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
+   stbi_uc *p, *temp_out, *orig = a->out;
+
+   p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);
+   if (p == NULL) return stbi__err("outofmem", "Out of memory");
+
+   // between here and free(out) below, exitting would leak
+   temp_out = p;
+
+   if (pal_img_n == 3) {
+      for (i=0; i < pixel_count; ++i) {
+         int n = orig[i]*4;
+         p[0] = palette[n  ];
+         p[1] = palette[n+1];
+         p[2] = palette[n+2];
+         p += 3;
+      }
+   } else {
+      for (i=0; i < pixel_count; ++i) {
+         int n = orig[i]*4;
+         p[0] = palette[n  ];
+         p[1] = palette[n+1];
+         p[2] = palette[n+2];
+         p[3] = palette[n+3];
+         p += 4;
+      }
+   }
+   STBI_FREE(a->out);
+   a->out = temp_out;
+
+   STBI_NOTUSED(len);
+
+   return 1;
+}
+
+static int stbi__unpremultiply_on_load = 0;
+static int stbi__de_iphone_flag = 0;
+
+STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
+{
+   stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply;
+}
+
+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
+{
+   stbi__de_iphone_flag = flag_true_if_should_convert;
+}
+
+static void stbi__de_iphone(stbi__png *z)
+{
+   stbi__context *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi_uc *p = z->out;
+
+   if (s->img_out_n == 3) {  // convert bgr to rgb
+      for (i=0; i < pixel_count; ++i) {
+         stbi_uc t = p[0];
+         p[0] = p[2];
+         p[2] = t;
+         p += 3;
+      }
+   } else {
+      STBI_ASSERT(s->img_out_n == 4);
+      if (stbi__unpremultiply_on_load) {
+         // convert bgr to rgb and unpremultiply
+         for (i=0; i < pixel_count; ++i) {
+            stbi_uc a = p[3];
+            stbi_uc t = p[0];
+            if (a) {
+               stbi_uc half = a / 2;
+               p[0] = (p[2] * 255 + half) / a;
+               p[1] = (p[1] * 255 + half) / a;
+               p[2] = ( t   * 255 + half) / a;
+            } else {
+               p[0] = p[2];
+               p[2] = t;
+            }
+            p += 4;
+         }
+      } else {
+         // convert bgr to rgb
+         for (i=0; i < pixel_count; ++i) {
+            stbi_uc t = p[0];
+            p[0] = p[2];
+            p[2] = t;
+            p += 4;
+         }
+      }
+   }
+}
+
+#define STBI__PNG_TYPE(a,b,c,d)  (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))
+
+static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
+{
+   stbi_uc palette[1024], pal_img_n=0;
+   stbi_uc has_trans=0, tc[3];
+   stbi__uint16 tc16[3];
+   stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
+   int first=1,k,interlace=0, color=0, is_iphone=0;
+   stbi__context *s = z->s;
+
+   z->expanded = NULL;
+   z->idata = NULL;
+   z->out = NULL;
+
+   if (!stbi__check_png_header(s)) return 0;
+
+   if (scan == STBI__SCAN_type) return 1;
+
+   for (;;) {
+      stbi__pngchunk c = stbi__get_chunk_header(s);
+      switch (c.type) {
+         case STBI__PNG_TYPE('C','g','B','I'):
+            is_iphone = 1;
+            stbi__skip(s, c.length);
+            break;
+         case STBI__PNG_TYPE('I','H','D','R'): {
+            int comp,filter;
+            if (!first) return stbi__err("multiple IHDR","Corrupt PNG");
+            first = 0;
+            if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG");
+            s->img_x = stbi__get32be(s); if (s->img_x > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)");
+            s->img_y = stbi__get32be(s); if (s->img_y > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)");
+            z->depth = stbi__get8(s);  if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16)  return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only");
+            color = stbi__get8(s);  if (color > 6)         return stbi__err("bad ctype","Corrupt PNG");
+            if (color == 3 && z->depth == 16)                  return stbi__err("bad ctype","Corrupt PNG");
+            if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG");
+            comp  = stbi__get8(s);  if (comp) return stbi__err("bad comp method","Corrupt PNG");
+            filter= stbi__get8(s);  if (filter) return stbi__err("bad filter method","Corrupt PNG");
+            interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG");
+            if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG");
+            if (!pal_img_n) {
+               s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
+               if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode");
+               if (scan == STBI__SCAN_header) return 1;
+            } else {
+               // if paletted, then pal_n is our final components, and
+               // img_n is # components to decompress/filter.
+               s->img_n = 1;
+               if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG");
+               // if SCAN_header, have to scan to see if we have a tRNS
+            }
+            break;
+         }
+
+         case STBI__PNG_TYPE('P','L','T','E'):  {
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG");
+            pal_len = c.length / 3;
+            if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG");
+            for (i=0; i < pal_len; ++i) {
+               palette[i*4+0] = stbi__get8(s);
+               palette[i*4+1] = stbi__get8(s);
+               palette[i*4+2] = stbi__get8(s);
+               palette[i*4+3] = 255;
+            }
+            break;
+         }
+
+         case STBI__PNG_TYPE('t','R','N','S'): {
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG");
+            if (pal_img_n) {
+               if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }
+               if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG");
+               if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG");
+               pal_img_n = 4;
+               for (i=0; i < c.length; ++i)
+                  palette[i*4+3] = stbi__get8(s);
+            } else {
+               if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");
+               if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");
+               has_trans = 1;
+               if (z->depth == 16) {
+                  for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is
+               } else {
+                  for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger
+               }
+            }
+            break;
+         }
+
+         case STBI__PNG_TYPE('I','D','A','T'): {
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");
+            if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; }
+            if ((int)(ioff + c.length) < (int)ioff) return 0;
+            if (ioff + c.length > idata_limit) {
+               stbi__uint32 idata_limit_old = idata_limit;
+               stbi_uc *p;
+               if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
+               while (ioff + c.length > idata_limit)
+                  idata_limit *= 2;
+               STBI_NOTUSED(idata_limit_old);
+               p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory");
+               z->idata = p;
+            }
+            if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG");
+            ioff += c.length;
+            break;
+         }
+
+         case STBI__PNG_TYPE('I','E','N','D'): {
+            stbi__uint32 raw_len, bpl;
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (scan != STBI__SCAN_load) return 1;
+            if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG");
+            // initial guess for decoded data size to avoid unnecessary reallocs
+            bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component
+            raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;
+            z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone);
+            if (z->expanded == NULL) return 0; // zlib should set error
+            STBI_FREE(z->idata); z->idata = NULL;
+            if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
+               s->img_out_n = s->img_n+1;
+            else
+               s->img_out_n = s->img_n;
+            if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0;
+            if (has_trans) {
+               if (z->depth == 16) {
+                  if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0;
+               } else {
+                  if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0;
+               }
+            }
+            if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
+               stbi__de_iphone(z);
+            if (pal_img_n) {
+               // pal_img_n == 3 or 4
+               s->img_n = pal_img_n; // record the actual colors we had
+               s->img_out_n = pal_img_n;
+               if (req_comp >= 3) s->img_out_n = req_comp;
+               if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
+                  return 0;
+            } else if (has_trans) {
+               // non-paletted image with tRNS -> source image has (constant) alpha
+               ++s->img_n;
+            }
+            STBI_FREE(z->expanded); z->expanded = NULL;
+            return 1;
+         }
+
+         default:
+            // if critical, fail
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if ((c.type & (1 << 29)) == 0) {
+               #ifndef STBI_NO_FAILURE_STRINGS
+               // not threadsafe
+               static char invalid_chunk[] = "XXXX PNG chunk not known";
+               invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
+               invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
+               invalid_chunk[2] = STBI__BYTECAST(c.type >>  8);
+               invalid_chunk[3] = STBI__BYTECAST(c.type >>  0);
+               #endif
+               return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type");
+            }
+            stbi__skip(s, c.length);
+            break;
+      }
+      // end of PNG chunk, read and skip CRC
+      stbi__get32be(s);
+   }
+}
+
+static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)
+{
+   void *result=NULL;
+   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
+   if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
+      if (p->depth < 8)
+         ri->bits_per_channel = 8;
+      else
+         ri->bits_per_channel = p->depth;
+      result = p->out;
+      p->out = NULL;
+      if (req_comp && req_comp != p->s->img_out_n) {
+         if (ri->bits_per_channel == 8)
+            result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+         else
+            result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+         p->s->img_out_n = req_comp;
+         if (result == NULL) return result;
+      }
+      *x = p->s->img_x;
+      *y = p->s->img_y;
+      if (n) *n = p->s->img_n;
+   }
+   STBI_FREE(p->out);      p->out      = NULL;
+   STBI_FREE(p->expanded); p->expanded = NULL;
+   STBI_FREE(p->idata);    p->idata    = NULL;
+
+   return result;
+}
+
+static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi__png p;
+   p.s = s;
+   return stbi__do_png(&p, x,y,comp,req_comp, ri);
+}
+
+static int stbi__png_test(stbi__context *s)
+{
+   int r;
+   r = stbi__check_png_header(s);
+   stbi__rewind(s);
+   return r;
+}
+
+static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
+{
+   if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
+      stbi__rewind( p->s );
+      return 0;
+   }
+   if (x) *x = p->s->img_x;
+   if (y) *y = p->s->img_y;
+   if (comp) *comp = p->s->img_n;
+   return 1;
+}
+
+static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   stbi__png p;
+   p.s = s;
+   return stbi__png_info_raw(&p, x, y, comp);
+}
+
+static int stbi__png_is16(stbi__context *s)
+{
+   stbi__png p;
+   p.s = s;
+   if (!stbi__png_info_raw(&p, NULL, NULL, NULL))
+	   return 0;
+   if (p.depth != 16) {
+      stbi__rewind(p.s);
+      return 0;
+   }
+   return 1;
+}
+#endif
+
+// Microsoft/Windows BMP image
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_test_raw(stbi__context *s)
+{
+   int r;
+   int sz;
+   if (stbi__get8(s) != 'B') return 0;
+   if (stbi__get8(s) != 'M') return 0;
+   stbi__get32le(s); // discard filesize
+   stbi__get16le(s); // discard reserved
+   stbi__get16le(s); // discard reserved
+   stbi__get32le(s); // discard data offset
+   sz = stbi__get32le(s);
+   r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
+   return r;
+}
+
+static int stbi__bmp_test(stbi__context *s)
+{
+   int r = stbi__bmp_test_raw(s);
+   stbi__rewind(s);
+   return r;
+}
+
+
+// returns 0..31 for the highest set bit
+static int stbi__high_bit(unsigned int z)
+{
+   int n=0;
+   if (z == 0) return -1;
+   if (z >= 0x10000) n += 16, z >>= 16;
+   if (z >= 0x00100) n +=  8, z >>=  8;
+   if (z >= 0x00010) n +=  4, z >>=  4;
+   if (z >= 0x00004) n +=  2, z >>=  2;
+   if (z >= 0x00002) n +=  1, z >>=  1;
+   return n;
+}
+
+static int stbi__bitcount(unsigned int a)
+{
+   a = (a & 0x55555555) + ((a >>  1) & 0x55555555); // max 2
+   a = (a & 0x33333333) + ((a >>  2) & 0x33333333); // max 4
+   a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
+   a = (a + (a >> 8)); // max 16 per 8 bits
+   a = (a + (a >> 16)); // max 32 per 8 bits
+   return a & 0xff;
+}
+
+// extract an arbitrarily-aligned N-bit value (N=bits)
+// from v, and then make it 8-bits long and fractionally
+// extend it to full full range.
+static int stbi__shiftsigned(int v, int shift, int bits)
+{
+   static unsigned int mul_table[9] = {
+      0,
+      0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
+      0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
+   };
+   static unsigned int shift_table[9] = {
+      0, 0,0,1,0,2,4,6,0,
+   };
+   if (shift < 0)
+      v <<= -shift;
+   else
+      v >>= shift;
+   STBI_ASSERT(v >= 0 && v < 256);
+   v >>= (8-bits);
+   STBI_ASSERT(bits >= 0 && bits <= 8);
+   return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
+}
+
+typedef struct
+{
+   int bpp, offset, hsz;
+   unsigned int mr,mg,mb,ma, all_a;
+} stbi__bmp_data;
+
+static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
+{
+   int hsz;
+   if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");
+   stbi__get32le(s); // discard filesize
+   stbi__get16le(s); // discard reserved
+   stbi__get16le(s); // discard reserved
+   info->offset = stbi__get32le(s);
+   info->hsz = hsz = stbi__get32le(s);
+   info->mr = info->mg = info->mb = info->ma = 0;
+
+   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");
+   if (hsz == 12) {
+      s->img_x = stbi__get16le(s);
+      s->img_y = stbi__get16le(s);
+   } else {
+      s->img_x = stbi__get32le(s);
+      s->img_y = stbi__get32le(s);
+   }
+   if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP");
+   info->bpp = stbi__get16le(s);
+   if (hsz != 12) {
+      int compress = stbi__get32le(s);
+      if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");
+      stbi__get32le(s); // discard sizeof
+      stbi__get32le(s); // discard hres
+      stbi__get32le(s); // discard vres
+      stbi__get32le(s); // discard colorsused
+      stbi__get32le(s); // discard max important
+      if (hsz == 40 || hsz == 56) {
+         if (hsz == 56) {
+            stbi__get32le(s);
+            stbi__get32le(s);
+            stbi__get32le(s);
+            stbi__get32le(s);
+         }
+         if (info->bpp == 16 || info->bpp == 32) {
+            if (compress == 0) {
+               if (info->bpp == 32) {
+                  info->mr = 0xffu << 16;
+                  info->mg = 0xffu <<  8;
+                  info->mb = 0xffu <<  0;
+                  info->ma = 0xffu << 24;
+                  info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0
+               } else {
+                  info->mr = 31u << 10;
+                  info->mg = 31u <<  5;
+                  info->mb = 31u <<  0;
+               }
+            } else if (compress == 3) {
+               info->mr = stbi__get32le(s);
+               info->mg = stbi__get32le(s);
+               info->mb = stbi__get32le(s);
+               // not documented, but generated by photoshop and handled by mspaint
+               if (info->mr == info->mg && info->mg == info->mb) {
+                  // ?!?!?
+                  return stbi__errpuc("bad BMP", "bad BMP");
+               }
+            } else
+               return stbi__errpuc("bad BMP", "bad BMP");
+         }
+      } else {
+         int i;
+         if (hsz != 108 && hsz != 124)
+            return stbi__errpuc("bad BMP", "bad BMP");
+         info->mr = stbi__get32le(s);
+         info->mg = stbi__get32le(s);
+         info->mb = stbi__get32le(s);
+         info->ma = stbi__get32le(s);
+         stbi__get32le(s); // discard color space
+         for (i=0; i < 12; ++i)
+            stbi__get32le(s); // discard color space parameters
+         if (hsz == 124) {
+            stbi__get32le(s); // discard rendering intent
+            stbi__get32le(s); // discard offset of profile data
+            stbi__get32le(s); // discard size of profile data
+            stbi__get32le(s); // discard reserved
+         }
+      }
+   }
+   return (void *) 1;
+}
+
+
+static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *out;
+   unsigned int mr=0,mg=0,mb=0,ma=0, all_a;
+   stbi_uc pal[256][4];
+   int psize=0,i,j,width;
+   int flip_vertically, pad, target;
+   stbi__bmp_data info;
+   STBI_NOTUSED(ri);
+
+   info.all_a = 255;
+   if (stbi__bmp_parse_header(s, &info) == NULL)
+      return NULL; // error code already set
+
+   flip_vertically = ((int) s->img_y) > 0;
+   s->img_y = abs((int) s->img_y);
+
+   mr = info.mr;
+   mg = info.mg;
+   mb = info.mb;
+   ma = info.ma;
+   all_a = info.all_a;
+
+   if (info.hsz == 12) {
+      if (info.bpp < 24)
+         psize = (info.offset - 14 - 24) / 3;
+   } else {
+      if (info.bpp < 16)
+         psize = (info.offset - 14 - info.hsz) >> 2;
+   }
+
+   s->img_n = ma ? 4 : 3;
+   if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
+      target = req_comp;
+   else
+      target = s->img_n; // if they want monochrome, we'll post-convert
+
+   // sanity-check size
+   if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))
+      return stbi__errpuc("too large", "Corrupt BMP");
+
+   out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0);
+   if (!out) return stbi__errpuc("outofmem", "Out of memory");
+   if (info.bpp < 16) {
+      int z=0;
+      if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); }
+      for (i=0; i < psize; ++i) {
+         pal[i][2] = stbi__get8(s);
+         pal[i][1] = stbi__get8(s);
+         pal[i][0] = stbi__get8(s);
+         if (info.hsz != 12) stbi__get8(s);
+         pal[i][3] = 255;
+      }
+      stbi__skip(s, info.offset - 14 - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
+      if (info.bpp == 1) width = (s->img_x + 7) >> 3;
+      else if (info.bpp == 4) width = (s->img_x + 1) >> 1;
+      else if (info.bpp == 8) width = s->img_x;
+      else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); }
+      pad = (-width)&3;
+      if (info.bpp == 1) {
+         for (j=0; j < (int) s->img_y; ++j) {
+            int bit_offset = 7, v = stbi__get8(s);
+            for (i=0; i < (int) s->img_x; ++i) {
+               int color = (v>>bit_offset)&0x1;
+               out[z++] = pal[color][0];
+               out[z++] = pal[color][1];
+               out[z++] = pal[color][2];
+               if((--bit_offset) < 0) {
+                  bit_offset = 7;
+                  v = stbi__get8(s);
+               }
+            }
+            stbi__skip(s, pad);
+         }
+      } else {
+         for (j=0; j < (int) s->img_y; ++j) {
+            for (i=0; i < (int) s->img_x; i += 2) {
+               int v=stbi__get8(s),v2=0;
+               if (info.bpp == 4) {
+                  v2 = v & 15;
+                  v >>= 4;
+               }
+               out[z++] = pal[v][0];
+               out[z++] = pal[v][1];
+               out[z++] = pal[v][2];
+               if (target == 4) out[z++] = 255;
+               if (i+1 == (int) s->img_x) break;
+               v = (info.bpp == 8) ? stbi__get8(s) : v2;
+               out[z++] = pal[v][0];
+               out[z++] = pal[v][1];
+               out[z++] = pal[v][2];
+               if (target == 4) out[z++] = 255;
+            }
+            stbi__skip(s, pad);
+         }
+      }
+   } else {
+      int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
+      int z = 0;
+      int easy=0;
+      stbi__skip(s, info.offset - 14 - info.hsz);
+      if (info.bpp == 24) width = 3 * s->img_x;
+      else if (info.bpp == 16) width = 2*s->img_x;
+      else /* bpp = 32 and pad = 0 */ width=0;
+      pad = (-width) & 3;
+      if (info.bpp == 24) {
+         easy = 1;
+      } else if (info.bpp == 32) {
+         if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
+            easy = 2;
+      }
+      if (!easy) {
+         if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
+         // right shift amt to put high bit in position #7
+         rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);
+         gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
+         bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
+         ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);
+      }
+      for (j=0; j < (int) s->img_y; ++j) {
+         if (easy) {
+            for (i=0; i < (int) s->img_x; ++i) {
+               unsigned char a;
+               out[z+2] = stbi__get8(s);
+               out[z+1] = stbi__get8(s);
+               out[z+0] = stbi__get8(s);
+               z += 3;
+               a = (easy == 2 ? stbi__get8(s) : 255);
+               all_a |= a;
+               if (target == 4) out[z++] = a;
+            }
+         } else {
+            int bpp = info.bpp;
+            for (i=0; i < (int) s->img_x; ++i) {
+               stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s));
+               unsigned int a;
+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
+               a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
+               all_a |= a;
+               if (target == 4) out[z++] = STBI__BYTECAST(a);
+            }
+         }
+         stbi__skip(s, pad);
+      }
+   }
+
+   // if alpha channel is all 0s, replace with all 255s
+   if (target == 4 && all_a == 0)
+      for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)
+         out[i] = 255;
+
+   if (flip_vertically) {
+      stbi_uc t;
+      for (j=0; j < (int) s->img_y>>1; ++j) {
+         stbi_uc *p1 = out +      j     *s->img_x*target;
+         stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
+         for (i=0; i < (int) s->img_x*target; ++i) {
+            t = p1[i], p1[i] = p2[i], p2[i] = t;
+         }
+      }
+   }
+
+   if (req_comp && req_comp != target) {
+      out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
+      if (out == NULL) return out; // stbi__convert_format frees input on failure
+   }
+
+   *x = s->img_x;
+   *y = s->img_y;
+   if (comp) *comp = s->img_n;
+   return out;
+}
+#endif
+
+// Targa Truevision - TGA
+// by Jonathan Dummer
+#ifndef STBI_NO_TGA
+// returns STBI_rgb or whatever, 0 on error
+static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
+{
+   // only RGB or RGBA (incl. 16bit) or grey allowed
+   if (is_rgb16) *is_rgb16 = 0;
+   switch(bits_per_pixel) {
+      case 8:  return STBI_grey;
+      case 16: if(is_grey) return STBI_grey_alpha;
+               // fallthrough
+      case 15: if(is_rgb16) *is_rgb16 = 1;
+               return STBI_rgb;
+      case 24: // fallthrough
+      case 32: return bits_per_pixel/8;
+      default: return 0;
+   }
+}
+
+static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
+{
+    int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
+    int sz, tga_colormap_type;
+    stbi__get8(s);                   // discard Offset
+    tga_colormap_type = stbi__get8(s); // colormap type
+    if( tga_colormap_type > 1 ) {
+        stbi__rewind(s);
+        return 0;      // only RGB or indexed allowed
+    }
+    tga_image_type = stbi__get8(s); // image type
+    if ( tga_colormap_type == 1 ) { // colormapped (paletted) image
+        if (tga_image_type != 1 && tga_image_type != 9) {
+            stbi__rewind(s);
+            return 0;
+        }
+        stbi__skip(s,4);       // skip index of first colormap entry and number of entries
+        sz = stbi__get8(s);    //   check bits per palette color entry
+        if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {
+            stbi__rewind(s);
+            return 0;
+        }
+        stbi__skip(s,4);       // skip image x and y origin
+        tga_colormap_bpp = sz;
+    } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE
+        if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {
+            stbi__rewind(s);
+            return 0; // only RGB or grey allowed, +/- RLE
+        }
+        stbi__skip(s,9); // skip colormap specification and image x/y origin
+        tga_colormap_bpp = 0;
+    }
+    tga_w = stbi__get16le(s);
+    if( tga_w < 1 ) {
+        stbi__rewind(s);
+        return 0;   // test width
+    }
+    tga_h = stbi__get16le(s);
+    if( tga_h < 1 ) {
+        stbi__rewind(s);
+        return 0;   // test height
+    }
+    tga_bits_per_pixel = stbi__get8(s); // bits per pixel
+    stbi__get8(s); // ignore alpha bits
+    if (tga_colormap_bpp != 0) {
+        if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
+            // when using a colormap, tga_bits_per_pixel is the size of the indexes
+            // I don't think anything but 8 or 16bit indexes makes sense
+            stbi__rewind(s);
+            return 0;
+        }
+        tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);
+    } else {
+        tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);
+    }
+    if(!tga_comp) {
+      stbi__rewind(s);
+      return 0;
+    }
+    if (x) *x = tga_w;
+    if (y) *y = tga_h;
+    if (comp) *comp = tga_comp;
+    return 1;                   // seems to have passed everything
+}
+
+static int stbi__tga_test(stbi__context *s)
+{
+   int res = 0;
+   int sz, tga_color_type;
+   stbi__get8(s);      //   discard Offset
+   tga_color_type = stbi__get8(s);   //   color type
+   if ( tga_color_type > 1 ) goto errorEnd;   //   only RGB or indexed allowed
+   sz = stbi__get8(s);   //   image type
+   if ( tga_color_type == 1 ) { // colormapped (paletted) image
+      if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9
+      stbi__skip(s,4);       // skip index of first colormap entry and number of entries
+      sz = stbi__get8(s);    //   check bits per palette color entry
+      if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
+      stbi__skip(s,4);       // skip image x and y origin
+   } else { // "normal" image w/o colormap
+      if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE
+      stbi__skip(s,9); // skip colormap specification and image x/y origin
+   }
+   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test width
+   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test height
+   sz = stbi__get8(s);   //   bits per pixel
+   if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index
+   if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
+
+   res = 1; // if we got this far, everything's good and we can return 1 instead of 0
+
+errorEnd:
+   stbi__rewind(s);
+   return res;
+}
+
+// read 16bit value and convert to 24bit RGB
+static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
+{
+   stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
+   stbi__uint16 fiveBitMask = 31;
+   // we have 3 channels with 5bits each
+   int r = (px >> 10) & fiveBitMask;
+   int g = (px >> 5) & fiveBitMask;
+   int b = px & fiveBitMask;
+   // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
+   out[0] = (stbi_uc)((r * 255)/31);
+   out[1] = (stbi_uc)((g * 255)/31);
+   out[2] = (stbi_uc)((b * 255)/31);
+
+   // some people claim that the most significant bit might be used for alpha
+   // (possibly if an alpha-bit is set in the "image descriptor byte")
+   // but that only made 16bit test images completely translucent..
+   // so let's treat all 15 and 16bit TGAs as RGB with no alpha.
+}
+
+static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   //   read in the TGA header stuff
+   int tga_offset = stbi__get8(s);
+   int tga_indexed = stbi__get8(s);
+   int tga_image_type = stbi__get8(s);
+   int tga_is_RLE = 0;
+   int tga_palette_start = stbi__get16le(s);
+   int tga_palette_len = stbi__get16le(s);
+   int tga_palette_bits = stbi__get8(s);
+   int tga_x_origin = stbi__get16le(s);
+   int tga_y_origin = stbi__get16le(s);
+   int tga_width = stbi__get16le(s);
+   int tga_height = stbi__get16le(s);
+   int tga_bits_per_pixel = stbi__get8(s);
+   int tga_comp, tga_rgb16=0;
+   int tga_inverted = stbi__get8(s);
+   // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)
+   //   image data
+   unsigned char *tga_data;
+   unsigned char *tga_palette = NULL;
+   int i, j;
+   unsigned char raw_data[4] = {0};
+   int RLE_count = 0;
+   int RLE_repeating = 0;
+   int read_next_pixel = 1;
+   STBI_NOTUSED(ri);
+
+   //   do a tiny bit of precessing
+   if ( tga_image_type >= 8 )
+   {
+      tga_image_type -= 8;
+      tga_is_RLE = 1;
+   }
+   tga_inverted = 1 - ((tga_inverted >> 5) & 1);
+
+   //   If I'm paletted, then I'll use the number of bits from the palette
+   if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
+   else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);
+
+   if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency
+      return stbi__errpuc("bad format", "Can't find out TGA pixelformat");
+
+   //   tga info
+   *x = tga_width;
+   *y = tga_height;
+   if (comp) *comp = tga_comp;
+
+   if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))
+      return stbi__errpuc("too large", "Corrupt TGA");
+
+   tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
+   if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");
+
+   // skip to the data's starting position (offset usually = 0)
+   stbi__skip(s, tga_offset );
+
+   if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {
+      for (i=0; i < tga_height; ++i) {
+         int row = tga_inverted ? tga_height -i - 1 : i;
+         stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;
+         stbi__getn(s, tga_row, tga_width * tga_comp);
+      }
+   } else  {
+      //   do I need to load a palette?
+      if ( tga_indexed)
+      {
+         //   any data to skip? (offset usually = 0)
+         stbi__skip(s, tga_palette_start );
+         //   load the palette
+         tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
+         if (!tga_palette) {
+            STBI_FREE(tga_data);
+            return stbi__errpuc("outofmem", "Out of memory");
+         }
+         if (tga_rgb16) {
+            stbi_uc *pal_entry = tga_palette;
+            STBI_ASSERT(tga_comp == STBI_rgb);
+            for (i=0; i < tga_palette_len; ++i) {
+               stbi__tga_read_rgb16(s, pal_entry);
+               pal_entry += tga_comp;
+            }
+         } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {
+               STBI_FREE(tga_data);
+               STBI_FREE(tga_palette);
+               return stbi__errpuc("bad palette", "Corrupt TGA");
+         }
+      }
+      //   load the data
+      for (i=0; i < tga_width * tga_height; ++i)
+      {
+         //   if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
+         if ( tga_is_RLE )
+         {
+            if ( RLE_count == 0 )
+            {
+               //   yep, get the next byte as a RLE command
+               int RLE_cmd = stbi__get8(s);
+               RLE_count = 1 + (RLE_cmd & 127);
+               RLE_repeating = RLE_cmd >> 7;
+               read_next_pixel = 1;
+            } else if ( !RLE_repeating )
+            {
+               read_next_pixel = 1;
+            }
+         } else
+         {
+            read_next_pixel = 1;
+         }
+         //   OK, if I need to read a pixel, do it now
+         if ( read_next_pixel )
+         {
+            //   load however much data we did have
+            if ( tga_indexed )
+            {
+               // read in index, then perform the lookup
+               int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
+               if ( pal_idx >= tga_palette_len ) {
+                  // invalid index
+                  pal_idx = 0;
+               }
+               pal_idx *= tga_comp;
+               for (j = 0; j < tga_comp; ++j) {
+                  raw_data[j] = tga_palette[pal_idx+j];
+               }
+            } else if(tga_rgb16) {
+               STBI_ASSERT(tga_comp == STBI_rgb);
+               stbi__tga_read_rgb16(s, raw_data);
+            } else {
+               //   read in the data raw
+               for (j = 0; j < tga_comp; ++j) {
+                  raw_data[j] = stbi__get8(s);
+               }
+            }
+            //   clear the reading flag for the next pixel
+            read_next_pixel = 0;
+         } // end of reading a pixel
+
+         // copy data
+         for (j = 0; j < tga_comp; ++j)
+           tga_data[i*tga_comp+j] = raw_data[j];
+
+         //   in case we're in RLE mode, keep counting down
+         --RLE_count;
+      }
+      //   do I need to invert the image?
+      if ( tga_inverted )
+      {
+         for (j = 0; j*2 < tga_height; ++j)
+         {
+            int index1 = j * tga_width * tga_comp;
+            int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
+            for (i = tga_width * tga_comp; i > 0; --i)
+            {
+               unsigned char temp = tga_data[index1];
+               tga_data[index1] = tga_data[index2];
+               tga_data[index2] = temp;
+               ++index1;
+               ++index2;
+            }
+         }
+      }
+      //   clear my palette, if I had one
+      if ( tga_palette != NULL )
+      {
+         STBI_FREE( tga_palette );
+      }
+   }
+
+   // swap RGB - if the source data was RGB16, it already is in the right order
+   if (tga_comp >= 3 && !tga_rgb16)
+   {
+      unsigned char* tga_pixel = tga_data;
+      for (i=0; i < tga_width * tga_height; ++i)
+      {
+         unsigned char temp = tga_pixel[0];
+         tga_pixel[0] = tga_pixel[2];
+         tga_pixel[2] = temp;
+         tga_pixel += tga_comp;
+      }
+   }
+
+   // convert to target component count
+   if (req_comp && req_comp != tga_comp)
+      tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
+
+   //   the things I do to get rid of an error message, and yet keep
+   //   Microsoft's C compilers happy... [8^(
+   tga_palette_start = tga_palette_len = tga_palette_bits =
+         tga_x_origin = tga_y_origin = 0;
+   //   OK, done
+   return tga_data;
+}
+#endif
+
+// *************************************************************************************************
+// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_test(stbi__context *s)
+{
+   int r = (stbi__get32be(s) == 0x38425053);
+   stbi__rewind(s);
+   return r;
+}
+
+static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
+{
+   int count, nleft, len;
+
+   count = 0;
+   while ((nleft = pixelCount - count) > 0) {
+      len = stbi__get8(s);
+      if (len == 128) {
+         // No-op.
+      } else if (len < 128) {
+         // Copy next len+1 bytes literally.
+         len++;
+         if (len > nleft) return 0; // corrupt data
+         count += len;
+         while (len) {
+            *p = stbi__get8(s);
+            p += 4;
+            len--;
+         }
+      } else if (len > 128) {
+         stbi_uc   val;
+         // Next -len+1 bytes in the dest are replicated from next source byte.
+         // (Interpret len as a negative 8-bit int.)
+         len = 257 - len;
+         if (len > nleft) return 0; // corrupt data
+         val = stbi__get8(s);
+         count += len;
+         while (len) {
+            *p = val;
+            p += 4;
+            len--;
+         }
+      }
+   }
+
+   return 1;
+}
+
+static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
+{
+   int pixelCount;
+   int channelCount, compression;
+   int channel, i;
+   int bitdepth;
+   int w,h;
+   stbi_uc *out;
+   STBI_NOTUSED(ri);
+
+   // Check identifier
+   if (stbi__get32be(s) != 0x38425053)   // "8BPS"
+      return stbi__errpuc("not PSD", "Corrupt PSD image");
+
+   // Check file type version.
+   if (stbi__get16be(s) != 1)
+      return stbi__errpuc("wrong version", "Unsupported version of PSD image");
+
+   // Skip 6 reserved bytes.
+   stbi__skip(s, 6 );
+
+   // Read the number of channels (R, G, B, A, etc).
+   channelCount = stbi__get16be(s);
+   if (channelCount < 0 || channelCount > 16)
+      return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");
+
+   // Read the rows and columns of the image.
+   h = stbi__get32be(s);
+   w = stbi__get32be(s);
+
+   // Make sure the depth is 8 bits.
+   bitdepth = stbi__get16be(s);
+   if (bitdepth != 8 && bitdepth != 16)
+      return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit");
+
+   // Make sure the color mode is RGB.
+   // Valid options are:
+   //   0: Bitmap
+   //   1: Grayscale
+   //   2: Indexed color
+   //   3: RGB color
+   //   4: CMYK color
+   //   7: Multichannel
+   //   8: Duotone
+   //   9: Lab color
+   if (stbi__get16be(s) != 3)
+      return stbi__errpuc("wrong color format", "PSD is not in RGB color format");
+
+   // Skip the Mode Data.  (It's the palette for indexed color; other info for other modes.)
+   stbi__skip(s,stbi__get32be(s) );
+
+   // Skip the image resources.  (resolution, pen tool paths, etc)
+   stbi__skip(s, stbi__get32be(s) );
+
+   // Skip the reserved data.
+   stbi__skip(s, stbi__get32be(s) );
+
+   // Find out if the data is compressed.
+   // Known values:
+   //   0: no compression
+   //   1: RLE compressed
+   compression = stbi__get16be(s);
+   if (compression > 1)
+      return stbi__errpuc("bad compression", "PSD has an unknown compression format");
+
+   // Check size
+   if (!stbi__mad3sizes_valid(4, w, h, 0))
+      return stbi__errpuc("too large", "Corrupt PSD");
+
+   // Create the destination image.
+
+   if (!compression && bitdepth == 16 && bpc == 16) {
+      out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0);
+      ri->bits_per_channel = 16;
+   } else
+      out = (stbi_uc *) stbi__malloc(4 * w*h);
+
+   if (!out) return stbi__errpuc("outofmem", "Out of memory");
+   pixelCount = w*h;
+
+   // Initialize the data to zero.
+   //memset( out, 0, pixelCount * 4 );
+
+   // Finally, the image data.
+   if (compression) {
+      // RLE as used by .PSD and .TIFF
+      // Loop until you get the number of unpacked bytes you are expecting:
+      //     Read the next source byte into n.
+      //     If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
+      //     Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
+      //     Else if n is 128, noop.
+      // Endloop
+
+      // The RLE-compressed data is preceeded by a 2-byte data count for each row in the data,
+      // which we're going to just skip.
+      stbi__skip(s, h * channelCount * 2 );
+
+      // Read the RLE data by channel.
+      for (channel = 0; channel < 4; channel++) {
+         stbi_uc *p;
+
+         p = out+channel;
+         if (channel >= channelCount) {
+            // Fill this channel with default data.
+            for (i = 0; i < pixelCount; i++, p += 4)
+               *p = (channel == 3 ? 255 : 0);
+         } else {
+            // Read the RLE data.
+            if (!stbi__psd_decode_rle(s, p, pixelCount)) {
+               STBI_FREE(out);
+               return stbi__errpuc("corrupt", "bad RLE data");
+            }
+         }
+      }
+
+   } else {
+      // We're at the raw image data.  It's each channel in order (Red, Green, Blue, Alpha, ...)
+      // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image.
+
+      // Read the data by channel.
+      for (channel = 0; channel < 4; channel++) {
+         if (channel >= channelCount) {
+            // Fill this channel with default data.
+            if (bitdepth == 16 && bpc == 16) {
+               stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
+               stbi__uint16 val = channel == 3 ? 65535 : 0;
+               for (i = 0; i < pixelCount; i++, q += 4)
+                  *q = val;
+            } else {
+               stbi_uc *p = out+channel;
+               stbi_uc val = channel == 3 ? 255 : 0;
+               for (i = 0; i < pixelCount; i++, p += 4)
+                  *p = val;
+            }
+         } else {
+            if (ri->bits_per_channel == 16) {    // output bpc
+               stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
+               for (i = 0; i < pixelCount; i++, q += 4)
+                  *q = (stbi__uint16) stbi__get16be(s);
+            } else {
+               stbi_uc *p = out+channel;
+               if (bitdepth == 16) {  // input bpc
+                  for (i = 0; i < pixelCount; i++, p += 4)
+                     *p = (stbi_uc) (stbi__get16be(s) >> 8);
+               } else {
+                  for (i = 0; i < pixelCount; i++, p += 4)
+                     *p = stbi__get8(s);
+               }
+            }
+         }
+      }
+   }
+
+   // remove weird white matte from PSD
+   if (channelCount >= 4) {
+      if (ri->bits_per_channel == 16) {
+         for (i=0; i < w*h; ++i) {
+            stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i;
+            if (pixel[3] != 0 && pixel[3] != 65535) {
+               float a = pixel[3] / 65535.0f;
+               float ra = 1.0f / a;
+               float inv_a = 65535.0f * (1 - ra);
+               pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a);
+               pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a);
+               pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a);
+            }
+         }
+      } else {
+         for (i=0; i < w*h; ++i) {
+            unsigned char *pixel = out + 4*i;
+            if (pixel[3] != 0 && pixel[3] != 255) {
+               float a = pixel[3] / 255.0f;
+               float ra = 1.0f / a;
+               float inv_a = 255.0f * (1 - ra);
+               pixel[0] = (unsigned char) (pixel[0]*ra + inv_a);
+               pixel[1] = (unsigned char) (pixel[1]*ra + inv_a);
+               pixel[2] = (unsigned char) (pixel[2]*ra + inv_a);
+            }
+         }
+      }
+   }
+
+   // convert to desired output format
+   if (req_comp && req_comp != 4) {
+      if (ri->bits_per_channel == 16)
+         out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h);
+      else
+         out = stbi__convert_format(out, 4, req_comp, w, h);
+      if (out == NULL) return out; // stbi__convert_format frees input on failure
+   }
+
+   if (comp) *comp = 4;
+   *y = h;
+   *x = w;
+
+   return out;
+}
+#endif
+
+// *************************************************************************************************
+// Softimage PIC loader
+// by Tom Seddon
+//
+// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
+// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_is4(stbi__context *s,const char *str)
+{
+   int i;
+   for (i=0; i<4; ++i)
+      if (stbi__get8(s) != (stbi_uc)str[i])
+         return 0;
+
+   return 1;
+}
+
+static int stbi__pic_test_core(stbi__context *s)
+{
+   int i;
+
+   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34"))
+      return 0;
+
+   for(i=0;i<84;++i)
+      stbi__get8(s);
+
+   if (!stbi__pic_is4(s,"PICT"))
+      return 0;
+
+   return 1;
+}
+
+typedef struct
+{
+   stbi_uc size,type,channel;
+} stbi__pic_packet;
+
+static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
+{
+   int mask=0x80, i;
+
+   for (i=0; i<4; ++i, mask>>=1) {
+      if (channel & mask) {
+         if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
+         dest[i]=stbi__get8(s);
+      }
+   }
+
+   return dest;
+}
+
+static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)
+{
+   int mask=0x80,i;
+
+   for (i=0;i<4; ++i, mask>>=1)
+      if (channel&mask)
+         dest[i]=src[i];
+}
+
+static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)
+{
+   int act_comp=0,num_packets=0,y,chained;
+   stbi__pic_packet packets[10];
+
+   // this will (should...) cater for even some bizarre stuff like having data
+    // for the same channel in multiple packets.
+   do {
+      stbi__pic_packet *packet;
+
+      if (num_packets==sizeof(packets)/sizeof(packets[0]))
+         return stbi__errpuc("bad format","too many packets");
+
+      packet = &packets[num_packets++];
+
+      chained = stbi__get8(s);
+      packet->size    = stbi__get8(s);
+      packet->type    = stbi__get8(s);
+      packet->channel = stbi__get8(s);
+
+      act_comp |= packet->channel;
+
+      if (stbi__at_eof(s))          return stbi__errpuc("bad file","file too short (reading packets)");
+      if (packet->size != 8)  return stbi__errpuc("bad format","packet isn't 8bpp");
+   } while (chained);
+
+   *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?
+
+   for(y=0; y<height; ++y) {
+      int packet_idx;
+
+      for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
+         stbi__pic_packet *packet = &packets[packet_idx];
+         stbi_uc *dest = result+y*width*4;
+
+         switch (packet->type) {
+            default:
+               return stbi__errpuc("bad format","packet has bad compression type");
+
+            case 0: {//uncompressed
+               int x;
+
+               for(x=0;x<width;++x, dest+=4)
+                  if (!stbi__readval(s,packet->channel,dest))
+                     return 0;
+               break;
+            }
+
+            case 1://Pure RLE
+               {
+                  int left=width, i;
+
+                  while (left>0) {
+                     stbi_uc count,value[4];
+
+                     count=stbi__get8(s);
+                     if (stbi__at_eof(s))   return stbi__errpuc("bad file","file too short (pure read count)");
+
+                     if (count > left)
+                        count = (stbi_uc) left;
+
+                     if (!stbi__readval(s,packet->channel,value))  return 0;
+
+                     for(i=0; i<count; ++i,dest+=4)
+                        stbi__copyval(packet->channel,dest,value);
+                     left -= count;
+                  }
+               }
+               break;
+
+            case 2: {//Mixed RLE
+               int left=width;
+               while (left>0) {
+                  int count = stbi__get8(s), i;
+                  if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (mixed read count)");
+
+                  if (count >= 128) { // Repeated
+                     stbi_uc value[4];
+
+                     if (count==128)
+                        count = stbi__get16be(s);
+                     else
+                        count -= 127;
+                     if (count > left)
+                        return stbi__errpuc("bad file","scanline overrun");
+
+                     if (!stbi__readval(s,packet->channel,value))
+                        return 0;
+
+                     for(i=0;i<count;++i, dest += 4)
+                        stbi__copyval(packet->channel,dest,value);
+                  } else { // Raw
+                     ++count;
+                     if (count>left) return stbi__errpuc("bad file","scanline overrun");
+
+                     for(i=0;i<count;++i, dest+=4)
+                        if (!stbi__readval(s,packet->channel,dest))
+                           return 0;
+                  }
+                  left-=count;
+               }
+               break;
+            }
+         }
+      }
+   }
+
+   return result;
+}
+
+static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *result;
+   int i, x,y, internal_comp;
+   STBI_NOTUSED(ri);
+
+   if (!comp) comp = &internal_comp;
+
+   for (i=0; i<92; ++i)
+      stbi__get8(s);
+
+   x = stbi__get16be(s);
+   y = stbi__get16be(s);
+   if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (pic header)");
+   if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode");
+
+   stbi__get32be(s); //skip `ratio'
+   stbi__get16be(s); //skip `fields'
+   stbi__get16be(s); //skip `pad'
+
+   // intermediate buffer is RGBA
+   result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);
+   memset(result, 0xff, x*y*4);
+
+   if (!stbi__pic_load_core(s,x,y,comp, result)) {
+      STBI_FREE(result);
+      result=0;
+   }
+   *px = x;
+   *py = y;
+   if (req_comp == 0) req_comp = *comp;
+   result=stbi__convert_format(result,4,req_comp,x,y);
+
+   return result;
+}
+
+static int stbi__pic_test(stbi__context *s)
+{
+   int r = stbi__pic_test_core(s);
+   stbi__rewind(s);
+   return r;
+}
+#endif
+
+// *************************************************************************************************
+// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
+
+#ifndef STBI_NO_GIF
+typedef struct
+{
+   stbi__int16 prefix;
+   stbi_uc first;
+   stbi_uc suffix;
+} stbi__gif_lzw;
+
+typedef struct
+{
+   int w,h;
+   stbi_uc *out;                 // output buffer (always 4 components)
+   stbi_uc *background;          // The current "background" as far as a gif is concerned
+   stbi_uc *history; 
+   int flags, bgindex, ratio, transparent, eflags;
+   stbi_uc  pal[256][4];
+   stbi_uc lpal[256][4];
+   stbi__gif_lzw codes[8192];
+   stbi_uc *color_table;
+   int parse, step;
+   int lflags;
+   int start_x, start_y;
+   int max_x, max_y;
+   int cur_x, cur_y;
+   int line_size;
+   int delay;
+} stbi__gif;
+
+static int stbi__gif_test_raw(stbi__context *s)
+{
+   int sz;
+   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;
+   sz = stbi__get8(s);
+   if (sz != '9' && sz != '7') return 0;
+   if (stbi__get8(s) != 'a') return 0;
+   return 1;
+}
+
+static int stbi__gif_test(stbi__context *s)
+{
+   int r = stbi__gif_test_raw(s);
+   stbi__rewind(s);
+   return r;
+}
+
+static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
+{
+   int i;
+   for (i=0; i < num_entries; ++i) {
+      pal[i][2] = stbi__get8(s);
+      pal[i][1] = stbi__get8(s);
+      pal[i][0] = stbi__get8(s);
+      pal[i][3] = transp == i ? 0 : 255;
+   }
+}
+
+static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)
+{
+   stbi_uc version;
+   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')
+      return stbi__err("not GIF", "Corrupt GIF");
+
+   version = stbi__get8(s);
+   if (version != '7' && version != '9')    return stbi__err("not GIF", "Corrupt GIF");
+   if (stbi__get8(s) != 'a')                return stbi__err("not GIF", "Corrupt GIF");
+
+   stbi__g_failure_reason = "";
+   g->w = stbi__get16le(s);
+   g->h = stbi__get16le(s);
+   g->flags = stbi__get8(s);
+   g->bgindex = stbi__get8(s);
+   g->ratio = stbi__get8(s);
+   g->transparent = -1;
+
+   if (comp != 0) *comp = 4;  // can't actually tell whether it's 3 or 4 until we parse the comments
+
+   if (is_info) return 1;
+
+   if (g->flags & 0x80)
+      stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
+
+   return 1;
+}
+
+static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
+{
+   stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));
+   if (!stbi__gif_header(s, g, comp, 1)) {
+      STBI_FREE(g);
+      stbi__rewind( s );
+      return 0;
+   }
+   if (x) *x = g->w;
+   if (y) *y = g->h;
+   STBI_FREE(g);
+   return 1;
+}
+
+static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
+{
+   stbi_uc *p, *c;
+   int idx; 
+
+   // recurse to decode the prefixes, since the linked-list is backwards,
+   // and working backwards through an interleaved image would be nasty
+   if (g->codes[code].prefix >= 0)
+      stbi__out_gif_code(g, g->codes[code].prefix);
+
+   if (g->cur_y >= g->max_y) return;
+
+   idx = g->cur_x + g->cur_y; 
+   p = &g->out[idx];
+   g->history[idx / 4] = 1;  
+
+   c = &g->color_table[g->codes[code].suffix * 4];
+   if (c[3] > 128) { // don't render transparent pixels; 
+      p[0] = c[2];
+      p[1] = c[1];
+      p[2] = c[0];
+      p[3] = c[3];
+   }
+   g->cur_x += 4;
+
+   if (g->cur_x >= g->max_x) {
+      g->cur_x = g->start_x;
+      g->cur_y += g->step;
+
+      while (g->cur_y >= g->max_y && g->parse > 0) {
+         g->step = (1 << g->parse) * g->line_size;
+         g->cur_y = g->start_y + (g->step >> 1);
+         --g->parse;
+      }
+   }
+}
+
+static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
+{
+   stbi_uc lzw_cs;
+   stbi__int32 len, init_code;
+   stbi__uint32 first;
+   stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
+   stbi__gif_lzw *p;
+
+   lzw_cs = stbi__get8(s);
+   if (lzw_cs > 12) return NULL;
+   clear = 1 << lzw_cs;
+   first = 1;
+   codesize = lzw_cs + 1;
+   codemask = (1 << codesize) - 1;
+   bits = 0;
+   valid_bits = 0;
+   for (init_code = 0; init_code < clear; init_code++) {
+      g->codes[init_code].prefix = -1;
+      g->codes[init_code].first = (stbi_uc) init_code;
+      g->codes[init_code].suffix = (stbi_uc) init_code;
+   }
+
+   // support no starting clear code
+   avail = clear+2;
+   oldcode = -1;
+
+   len = 0;
+   for(;;) {
+      if (valid_bits < codesize) {
+         if (len == 0) {
+            len = stbi__get8(s); // start new block
+            if (len == 0)
+               return g->out;
+         }
+         --len;
+         bits |= (stbi__int32) stbi__get8(s) << valid_bits;
+         valid_bits += 8;
+      } else {
+         stbi__int32 code = bits & codemask;
+         bits >>= codesize;
+         valid_bits -= codesize;
+         // @OPTIMIZE: is there some way we can accelerate the non-clear path?
+         if (code == clear) {  // clear code
+            codesize = lzw_cs + 1;
+            codemask = (1 << codesize) - 1;
+            avail = clear + 2;
+            oldcode = -1;
+            first = 0;
+         } else if (code == clear + 1) { // end of stream code
+            stbi__skip(s, len);
+            while ((len = stbi__get8(s)) > 0)
+               stbi__skip(s,len);
+            return g->out;
+         } else if (code <= avail) {
+            if (first) {
+               return stbi__errpuc("no clear code", "Corrupt GIF");
+            }
+
+            if (oldcode >= 0) {
+               p = &g->codes[avail++];
+               if (avail > 8192) {
+                  return stbi__errpuc("too many codes", "Corrupt GIF");
+               }
+
+               p->prefix = (stbi__int16) oldcode;
+               p->first = g->codes[oldcode].first;
+               p->suffix = (code == avail) ? p->first : g->codes[code].first;
+            } else if (code == avail)
+               return stbi__errpuc("illegal code in raster", "Corrupt GIF");
+
+            stbi__out_gif_code(g, (stbi__uint16) code);
+
+            if ((avail & codemask) == 0 && avail <= 0x0FFF) {
+               codesize++;
+               codemask = (1 << codesize) - 1;
+            }
+
+            oldcode = code;
+         } else {
+            return stbi__errpuc("illegal code in raster", "Corrupt GIF");
+         }
+      }
+   }
+}
+
+// this function is designed to support animated gifs, although stb_image doesn't support it
+// two back is the image from two frames ago, used for a very specific disposal format
+static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)
+{
+   int dispose; 
+   int first_frame; 
+   int pi; 
+   int pcount; 
+
+   // on first frame, any non-written pixels get the background colour (non-transparent)
+   first_frame = 0; 
+   if (g->out == 0) {
+      if (!stbi__gif_header(s, g, comp,0))     return 0; // stbi__g_failure_reason set by stbi__gif_header
+      g->out = (stbi_uc *) stbi__malloc(4 * g->w * g->h);
+      g->background = (stbi_uc *) stbi__malloc(4 * g->w * g->h); 
+      g->history = (stbi_uc *) stbi__malloc(g->w * g->h); 
+      if (g->out == 0)                      return stbi__errpuc("outofmem", "Out of memory");
+
+      // image is treated as "tranparent" at the start - ie, nothing overwrites the current background; 
+      // background colour is only used for pixels that are not rendered first frame, after that "background"
+      // color refers to teh color that was there the previous frame. 
+      memset( g->out, 0x00, 4 * g->w * g->h ); 
+      memset( g->background, 0x00, 4 * g->w * g->h ); // state of the background (starts transparent)
+      memset( g->history, 0x00, g->w * g->h );        // pixels that were affected previous frame
+      first_frame = 1; 
+   } else {
+      // second frame - how do we dispoase of the previous one?
+      dispose = (g->eflags & 0x1C) >> 2; 
+      pcount = g->w * g->h; 
+
+      if ((dispose == 3) && (two_back == 0)) {
+         dispose = 2; // if I don't have an image to revert back to, default to the old background
+      }
+
+      if (dispose == 3) { // use previous graphic
+         for (pi = 0; pi < pcount; ++pi) {
+            if (g->history[pi]) {
+               memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); 
+            }
+         }
+      } else if (dispose == 2) { 
+         // restore what was changed last frame to background before that frame; 
+         for (pi = 0; pi < pcount; ++pi) {
+            if (g->history[pi]) {
+               memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); 
+            }
+         }
+      } else {
+         // This is a non-disposal case eithe way, so just 
+         // leave the pixels as is, and they will become the new background
+         // 1: do not dispose
+         // 0:  not specified.
+      }
+
+      // background is what out is after the undoing of the previou frame; 
+      memcpy( g->background, g->out, 4 * g->w * g->h ); 
+   }
+
+   // clear my history; 
+   memset( g->history, 0x00, g->w * g->h );        // pixels that were affected previous frame
+
+   for (;;) {
+      int tag = stbi__get8(s); 
+      switch (tag) {
+         case 0x2C: /* Image Descriptor */
+         {
+            stbi__int32 x, y, w, h;
+            stbi_uc *o;
+
+            x = stbi__get16le(s);
+            y = stbi__get16le(s);
+            w = stbi__get16le(s);
+            h = stbi__get16le(s);
+            if (((x + w) > (g->w)) || ((y + h) > (g->h)))
+               return stbi__errpuc("bad Image Descriptor", "Corrupt GIF");
+
+            g->line_size = g->w * 4;
+            g->start_x = x * 4;
+            g->start_y = y * g->line_size;
+            g->max_x   = g->start_x + w * 4;
+            g->max_y   = g->start_y + h * g->line_size;
+            g->cur_x   = g->start_x;
+            g->cur_y   = g->start_y;
+
+            g->lflags = stbi__get8(s);
+
+            if (g->lflags & 0x40) {
+               g->step = 8 * g->line_size; // first interlaced spacing
+               g->parse = 3;
+            } else {
+               g->step = g->line_size;
+               g->parse = 0;
+            }
+
+            if (g->lflags & 0x80) {
+               stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
+               g->color_table = (stbi_uc *) g->lpal;
+            } else if (g->flags & 0x80) {
+               g->color_table = (stbi_uc *) g->pal;
+            } else
+               return stbi__errpuc("missing color table", "Corrupt GIF");            
+            
+            o = stbi__process_gif_raster(s, g);
+            if (o == NULL) return NULL;
+
+            // if this was the first frame, 
+            pcount = g->w * g->h; 
+            if (first_frame && (g->bgindex > 0)) {
+               // if first frame, any pixel not drawn to gets the background color
+               for (pi = 0; pi < pcount; ++pi) {
+                  if (g->history[pi] == 0) {
+                     g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; 
+                     memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); 
+                  }
+               }
+            }
+
+            return o;
+         }
+
+         case 0x21: // Comment Extension.
+         {
+            int len;
+            int ext = stbi__get8(s); 
+            if (ext == 0xF9) { // Graphic Control Extension.
+               len = stbi__get8(s);
+               if (len == 4) {
+                  g->eflags = stbi__get8(s);
+                  g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths.
+
+                  // unset old transparent
+                  if (g->transparent >= 0) {
+                     g->pal[g->transparent][3] = 255; 
+                  } 
+                  if (g->eflags & 0x01) {
+                     g->transparent = stbi__get8(s);
+                     if (g->transparent >= 0) {
+                        g->pal[g->transparent][3] = 0; 
+                     }
+                  } else {
+                     // don't need transparent
+                     stbi__skip(s, 1); 
+                     g->transparent = -1; 
+                  }
+               } else {
+                  stbi__skip(s, len);
+                  break;
+               }
+            } 
+            while ((len = stbi__get8(s)) != 0) {
+               stbi__skip(s, len);
+            }
+            break;
+         }
+
+         case 0x3B: // gif stream termination code
+            return (stbi_uc *) s; // using '1' causes warning on some compilers
+
+         default:
+            return stbi__errpuc("unknown code", "Corrupt GIF");
+      }
+   }
+}
+
+static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
+{
+   if (stbi__gif_test(s)) {
+      int layers = 0; 
+      stbi_uc *u = 0;
+      stbi_uc *out = 0;
+      stbi_uc *two_back = 0; 
+      stbi__gif g;
+      int stride; 
+      memset(&g, 0, sizeof(g));
+      if (delays) {
+         *delays = 0; 
+      }
+
+      do {
+         u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);
+         if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
+
+         if (u) {
+            *x = g.w;
+            *y = g.h;
+            ++layers; 
+            stride = g.w * g.h * 4; 
+         
+            if (out) {
+               out = (stbi_uc*) STBI_REALLOC( out, layers * stride ); 
+               if (delays) {
+                  *delays = (int*) STBI_REALLOC( *delays, sizeof(int) * layers ); 
+               }
+            } else {
+               out = (stbi_uc*)stbi__malloc( layers * stride ); 
+               if (delays) {
+                  *delays = (int*) stbi__malloc( layers * sizeof(int) ); 
+               }
+            }
+            memcpy( out + ((layers - 1) * stride), u, stride ); 
+            if (layers >= 2) {
+               two_back = out - 2 * stride; 
+            }
+
+            if (delays) {
+               (*delays)[layers - 1U] = g.delay; 
+            }
+         }
+      } while (u != 0); 
+
+      // free temp buffer; 
+      STBI_FREE(g.out); 
+      STBI_FREE(g.history); 
+      STBI_FREE(g.background); 
+
+      // do the final conversion after loading everything; 
+      if (req_comp && req_comp != 4)
+         out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
+
+      *z = layers; 
+      return out;
+   } else {
+      return stbi__errpuc("not GIF", "Image was not as a gif type."); 
+   }
+}
+
+static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *u = 0;
+   stbi__gif g;
+   memset(&g, 0, sizeof(g));
+
+   u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
+   if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
+   if (u) {
+      *x = g.w;
+      *y = g.h;
+
+      // moved conversion to after successful load so that the same
+      // can be done for multiple frames. 
+      if (req_comp && req_comp != 4)
+         u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
+   }
+
+   // free buffers needed for multiple frame loading; 
+   STBI_FREE(g.history);
+   STBI_FREE(g.background); 
+
+   return u;
+}
+
+static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   return stbi__gif_info_raw(s,x,y,comp);
+}
+#endif
+
+// *************************************************************************************************
+// Radiance RGBE HDR loader
+// originally by Nicolas Schulz
+#ifndef STBI_NO_HDR
+static int stbi__hdr_test_core(stbi__context *s, const char *signature)
+{
+   int i;
+   for (i=0; signature[i]; ++i)
+      if (stbi__get8(s) != signature[i])
+          return 0;
+   stbi__rewind(s);
+   return 1;
+}
+
+static int stbi__hdr_test(stbi__context* s)
+{
+   int r = stbi__hdr_test_core(s, "#?RADIANCE\n");
+   stbi__rewind(s);
+   if(!r) {
+       r = stbi__hdr_test_core(s, "#?RGBE\n");
+       stbi__rewind(s);
+   }
+   return r;
+}
+
+#define STBI__HDR_BUFLEN  1024
+static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
+{
+   int len=0;
+   char c = '\0';
+
+   c = (char) stbi__get8(z);
+
+   while (!stbi__at_eof(z) && c != '\n') {
+      buffer[len++] = c;
+      if (len == STBI__HDR_BUFLEN-1) {
+         // flush to end of line
+         while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
+            ;
+         break;
+      }
+      c = (char) stbi__get8(z);
+   }
+
+   buffer[len] = 0;
+   return buffer;
+}
+
+static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
+{
+   if ( input[3] != 0 ) {
+      float f1;
+      // Exponent
+      f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
+      if (req_comp <= 2)
+         output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
+      else {
+         output[0] = input[0] * f1;
+         output[1] = input[1] * f1;
+         output[2] = input[2] * f1;
+      }
+      if (req_comp == 2) output[1] = 1;
+      if (req_comp == 4) output[3] = 1;
+   } else {
+      switch (req_comp) {
+         case 4: output[3] = 1; /* fallthrough */
+         case 3: output[0] = output[1] = output[2] = 0;
+                 break;
+         case 2: output[1] = 1; /* fallthrough */
+         case 1: output[0] = 0;
+                 break;
+      }
+   }
+}
+
+static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   char buffer[STBI__HDR_BUFLEN];
+   char *token;
+   int valid = 0;
+   int width, height;
+   stbi_uc *scanline;
+   float *hdr_data;
+   int len;
+   unsigned char count, value;
+   int i, j, k, c1,c2, z;
+   const char *headerToken;
+   STBI_NOTUSED(ri);
+
+   // Check identifier
+   headerToken = stbi__hdr_gettoken(s,buffer);
+   if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0)
+      return stbi__errpf("not HDR", "Corrupt HDR image");
+
+   // Parse header
+   for(;;) {
+      token = stbi__hdr_gettoken(s,buffer);
+      if (token[0] == 0) break;
+      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+   }
+
+   if (!valid)    return stbi__errpf("unsupported format", "Unsupported HDR format");
+
+   // Parse width and height
+   // can't use sscanf() if we're not using stdio!
+   token = stbi__hdr_gettoken(s,buffer);
+   if (strncmp(token, "-Y ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");
+   token += 3;
+   height = (int) strtol(token, &token, 10);
+   while (*token == ' ') ++token;
+   if (strncmp(token, "+X ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");
+   token += 3;
+   width = (int) strtol(token, NULL, 10);
+
+   *x = width;
+   *y = height;
+
+   if (comp) *comp = 3;
+   if (req_comp == 0) req_comp = 3;
+
+   if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0))
+      return stbi__errpf("too large", "HDR image is too large");
+
+   // Read data
+   hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0);
+   if (!hdr_data)
+      return stbi__errpf("outofmem", "Out of memory");
+
+   // Load image data
+   // image data is stored as some number of sca
+   if ( width < 8 || width >= 32768) {
+      // Read flat data
+      for (j=0; j < height; ++j) {
+         for (i=0; i < width; ++i) {
+            stbi_uc rgbe[4];
+           main_decode_loop:
+            stbi__getn(s, rgbe, 4);
+            stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
+         }
+      }
+   } else {
+      // Read RLE-encoded data
+      scanline = NULL;
+
+      for (j = 0; j < height; ++j) {
+         c1 = stbi__get8(s);
+         c2 = stbi__get8(s);
+         len = stbi__get8(s);
+         if (c1 != 2 || c2 != 2 || (len & 0x80)) {
+            // not run-length encoded, so we have to actually use THIS data as a decoded
+            // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
+            stbi_uc rgbe[4];
+            rgbe[0] = (stbi_uc) c1;
+            rgbe[1] = (stbi_uc) c2;
+            rgbe[2] = (stbi_uc) len;
+            rgbe[3] = (stbi_uc) stbi__get8(s);
+            stbi__hdr_convert(hdr_data, rgbe, req_comp);
+            i = 1;
+            j = 0;
+            STBI_FREE(scanline);
+            goto main_decode_loop; // yes, this makes no sense
+         }
+         len <<= 8;
+         len |= stbi__get8(s);
+         if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); }
+         if (scanline == NULL) {
+            scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0);
+            if (!scanline) {
+               STBI_FREE(hdr_data);
+               return stbi__errpf("outofmem", "Out of memory");
+            }
+         }
+
+         for (k = 0; k < 4; ++k) {
+            int nleft;
+            i = 0;
+            while ((nleft = width - i) > 0) {
+               count = stbi__get8(s);
+               if (count > 128) {
+                  // Run
+                  value = stbi__get8(s);
+                  count -= 128;
+                  if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
+                  for (z = 0; z < count; ++z)
+                     scanline[i++ * 4 + k] = value;
+               } else {
+                  // Dump
+                  if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
+                  for (z = 0; z < count; ++z)
+                     scanline[i++ * 4 + k] = stbi__get8(s);
+               }
+            }
+         }
+         for (i=0; i < width; ++i)
+            stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
+      }
+      if (scanline)
+         STBI_FREE(scanline);
+   }
+
+   return hdr_data;
+}
+
+static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   char buffer[STBI__HDR_BUFLEN];
+   char *token;
+   int valid = 0;
+   int dummy;
+
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+
+   if (stbi__hdr_test(s) == 0) {
+       stbi__rewind( s );
+       return 0;
+   }
+
+   for(;;) {
+      token = stbi__hdr_gettoken(s,buffer);
+      if (token[0] == 0) break;
+      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+   }
+
+   if (!valid) {
+       stbi__rewind( s );
+       return 0;
+   }
+   token = stbi__hdr_gettoken(s,buffer);
+   if (strncmp(token, "-Y ", 3)) {
+       stbi__rewind( s );
+       return 0;
+   }
+   token += 3;
+   *y = (int) strtol(token, &token, 10);
+   while (*token == ' ') ++token;
+   if (strncmp(token, "+X ", 3)) {
+       stbi__rewind( s );
+       return 0;
+   }
+   token += 3;
+   *x = (int) strtol(token, NULL, 10);
+   *comp = 3;
+   return 1;
+}
+#endif // STBI_NO_HDR
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   void *p;
+   stbi__bmp_data info;
+
+   info.all_a = 255;
+   p = stbi__bmp_parse_header(s, &info);
+   stbi__rewind( s );
+   if (p == NULL)
+      return 0;
+   if (x) *x = s->img_x;
+   if (y) *y = s->img_y;
+   if (comp) *comp = info.ma ? 4 : 3;
+   return 1;
+}
+#endif
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int channelCount, dummy, depth;
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+   if (stbi__get32be(s) != 0x38425053) {
+       stbi__rewind( s );
+       return 0;
+   }
+   if (stbi__get16be(s) != 1) {
+       stbi__rewind( s );
+       return 0;
+   }
+   stbi__skip(s, 6);
+   channelCount = stbi__get16be(s);
+   if (channelCount < 0 || channelCount > 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   *y = stbi__get32be(s);
+   *x = stbi__get32be(s);
+   depth = stbi__get16be(s);
+   if (depth != 8 && depth != 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   if (stbi__get16be(s) != 3) {
+       stbi__rewind( s );
+       return 0;
+   }
+   *comp = 4;
+   return 1;
+}
+
+static int stbi__psd_is16(stbi__context *s)
+{
+   int channelCount, depth;
+   if (stbi__get32be(s) != 0x38425053) {
+       stbi__rewind( s );
+       return 0;
+   }
+   if (stbi__get16be(s) != 1) {
+       stbi__rewind( s );
+       return 0;
+   }
+   stbi__skip(s, 6);
+   channelCount = stbi__get16be(s);
+   if (channelCount < 0 || channelCount > 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   (void) stbi__get32be(s);
+   (void) stbi__get32be(s);
+   depth = stbi__get16be(s);
+   if (depth != 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   return 1;
+}
+#endif
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int act_comp=0,num_packets=0,chained,dummy;
+   stbi__pic_packet packets[10];
+
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+
+   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) {
+      stbi__rewind(s);
+      return 0;
+   }
+
+   stbi__skip(s, 88);
+
+   *x = stbi__get16be(s);
+   *y = stbi__get16be(s);
+   if (stbi__at_eof(s)) {
+      stbi__rewind( s);
+      return 0;
+   }
+   if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
+      stbi__rewind( s );
+      return 0;
+   }
+
+   stbi__skip(s, 8);
+
+   do {
+      stbi__pic_packet *packet;
+
+      if (num_packets==sizeof(packets)/sizeof(packets[0]))
+         return 0;
+
+      packet = &packets[num_packets++];
+      chained = stbi__get8(s);
+      packet->size    = stbi__get8(s);
+      packet->type    = stbi__get8(s);
+      packet->channel = stbi__get8(s);
+      act_comp |= packet->channel;
+
+      if (stbi__at_eof(s)) {
+          stbi__rewind( s );
+          return 0;
+      }
+      if (packet->size != 8) {
+          stbi__rewind( s );
+          return 0;
+      }
+   } while (chained);
+
+   *comp = (act_comp & 0x10 ? 4 : 3);
+
+   return 1;
+}
+#endif
+
+// *************************************************************************************************
+// Portable Gray Map and Portable Pixel Map loader
+// by Ken Miller
+//
+// PGM: http://netpbm.sourceforge.net/doc/pgm.html
+// PPM: http://netpbm.sourceforge.net/doc/ppm.html
+//
+// Known limitations:
+//    Does not support comments in the header section
+//    Does not support ASCII image data (formats P2 and P3)
+//    Does not support 16-bit-per-channel
+
+#ifndef STBI_NO_PNM
+
+static int      stbi__pnm_test(stbi__context *s)
+{
+   char p, t;
+   p = (char) stbi__get8(s);
+   t = (char) stbi__get8(s);
+   if (p != 'P' || (t != '5' && t != '6')) {
+       stbi__rewind( s );
+       return 0;
+   }
+   return 1;
+}
+
+static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *out;
+   STBI_NOTUSED(ri);
+
+   if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n))
+      return 0;
+
+   *x = s->img_x;
+   *y = s->img_y;
+   if (comp) *comp = s->img_n;
+
+   if (!stbi__mad3sizes_valid(s->img_n, s->img_x, s->img_y, 0))
+      return stbi__errpuc("too large", "PNM too large");
+
+   out = (stbi_uc *) stbi__malloc_mad3(s->img_n, s->img_x, s->img_y, 0);
+   if (!out) return stbi__errpuc("outofmem", "Out of memory");
+   stbi__getn(s, out, s->img_n * s->img_x * s->img_y);
+
+   if (req_comp && req_comp != s->img_n) {
+      out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
+      if (out == NULL) return out; // stbi__convert_format frees input on failure
+   }
+   return out;
+}
+
+static int      stbi__pnm_isspace(char c)
+{
+   return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
+}
+
+static void     stbi__pnm_skip_whitespace(stbi__context *s, char *c)
+{
+   for (;;) {
+      while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
+         *c = (char) stbi__get8(s);
+
+      if (stbi__at_eof(s) || *c != '#')
+         break;
+
+      while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' )
+         *c = (char) stbi__get8(s);
+   }
+}
+
+static int      stbi__pnm_isdigit(char c)
+{
+   return c >= '0' && c <= '9';
+}
+
+static int      stbi__pnm_getinteger(stbi__context *s, char *c)
+{
+   int value = 0;
+
+   while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
+      value = value*10 + (*c - '0');
+      *c = (char) stbi__get8(s);
+   }
+
+   return value;
+}
+
+static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int maxv, dummy;
+   char c, p, t;
+
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+
+   stbi__rewind(s);
+
+   // Get identifier
+   p = (char) stbi__get8(s);
+   t = (char) stbi__get8(s);
+   if (p != 'P' || (t != '5' && t != '6')) {
+       stbi__rewind(s);
+       return 0;
+   }
+
+   *comp = (t == '6') ? 3 : 1;  // '5' is 1-component .pgm; '6' is 3-component .ppm
+
+   c = (char) stbi__get8(s);
+   stbi__pnm_skip_whitespace(s, &c);
+
+   *x = stbi__pnm_getinteger(s, &c); // read width
+   stbi__pnm_skip_whitespace(s, &c);
+
+   *y = stbi__pnm_getinteger(s, &c); // read height
+   stbi__pnm_skip_whitespace(s, &c);
+
+   maxv = stbi__pnm_getinteger(s, &c);  // read max value
+
+   if (maxv > 255)
+      return stbi__err("max value > 255", "PPM image not 8-bit");
+   else
+      return 1;
+}
+#endif
+
+static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
+{
+   #ifndef STBI_NO_JPEG
+   if (stbi__jpeg_info(s, x, y, comp)) return 1;
+   #endif
+
+   #ifndef STBI_NO_PNG
+   if (stbi__png_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_GIF
+   if (stbi__gif_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_BMP
+   if (stbi__bmp_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PIC
+   if (stbi__pic_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PNM
+   if (stbi__pnm_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_info(s, x, y, comp))  return 1;
+   #endif
+
+   // test tga last because it's a crappy test!
+   #ifndef STBI_NO_TGA
+   if (stbi__tga_info(s, x, y, comp))
+       return 1;
+   #endif
+   return stbi__err("unknown image type", "Image not of any known type, or corrupt");
+}
+
+static int stbi__is_16_main(stbi__context *s)
+{
+   #ifndef STBI_NO_PNG
+   if (stbi__png_is16(s))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_is16(s))  return 1;
+   #endif
+
+   return 0;
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
+{
+    FILE *f = stbi__fopen(filename, "rb");
+    int result;
+    if (!f) return stbi__err("can't fopen", "Unable to open file");
+    result = stbi_info_from_file(f, x, y, comp);
+    fclose(f);
+    return result;
+}
+
+STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
+{
+   int r;
+   stbi__context s;
+   long pos = ftell(f);
+   stbi__start_file(&s, f);
+   r = stbi__info_main(&s,x,y,comp);
+   fseek(f,pos,SEEK_SET);
+   return r;
+}
+
+STBIDEF int stbi_is_16_bit(char const *filename)
+{
+    FILE *f = stbi__fopen(filename, "rb");
+    int result;
+    if (!f) return stbi__err("can't fopen", "Unable to open file");
+    result = stbi_is_16_bit_from_file(f);
+    fclose(f);
+    return result;
+}
+
+STBIDEF int stbi_is_16_bit_from_file(FILE *f)
+{
+   int r;
+   stbi__context s;
+   long pos = ftell(f);
+   stbi__start_file(&s, f);
+   r = stbi__is_16_main(&s);
+   fseek(f,pos,SEEK_SET);
+   return r;
+}
+#endif // !STBI_NO_STDIO
+
+STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__info_main(&s,x,y,comp);
+}
+
+STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
+   return stbi__info_main(&s,x,y,comp);
+}
+
+STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__is_16_main(&s);
+}
+
+STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
+   return stbi__is_16_main(&s);
+}
+
+#endif // STB_IMAGE_IMPLEMENTATION
+
+/*
+   revision history:
+      2.19  (2018-02-11) fix warning
+      2.18  (2018-01-30) fix warnings
+      2.17  (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug
+                         1-bit BMP
+                         *_is_16_bit api
+                         avoid warnings
+      2.16  (2017-07-23) all functions have 16-bit variants;
+                         STBI_NO_STDIO works again;
+                         compilation fixes;
+                         fix rounding in unpremultiply;
+                         optimize vertical flip;
+                         disable raw_len validation;
+                         documentation fixes
+      2.15  (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode;
+                         warning fixes; disable run-time SSE detection on gcc;
+                         uniform handling of optional "return" values;
+                         thread-safe initialization of zlib tables
+      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
+      2.13  (2016-11-29) add 16-bit API, only supported for PNG right now
+      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
+      2.11  (2016-04-02) allocate large structures on the stack
+                         remove white matting for transparent PSD
+                         fix reported channel count for PNG & BMP
+                         re-enable SSE2 in non-gcc 64-bit
+                         support RGB-formatted JPEG
+                         read 16-bit PNGs (only as 8-bit)
+      2.10  (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED
+      2.09  (2016-01-16) allow comments in PNM files
+                         16-bit-per-pixel TGA (not bit-per-component)
+                         info() for TGA could break due to .hdr handling
+                         info() for BMP to shares code instead of sloppy parse
+                         can use STBI_REALLOC_SIZED if allocator doesn't support realloc
+                         code cleanup
+      2.08  (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA
+      2.07  (2015-09-13) fix compiler warnings
+                         partial animated GIF support
+                         limited 16-bpc PSD support
+                         #ifdef unused functions
+                         bug with < 92 byte PIC,PNM,HDR,TGA
+      2.06  (2015-04-19) fix bug where PSD returns wrong '*comp' value
+      2.05  (2015-04-19) fix bug in progressive JPEG handling, fix warning
+      2.04  (2015-04-15) try to re-enable SIMD on MinGW 64-bit
+      2.03  (2015-04-12) extra corruption checking (mmozeiko)
+                         stbi_set_flip_vertically_on_load (nguillemot)
+                         fix NEON support; fix mingw support
+      2.02  (2015-01-19) fix incorrect assert, fix warning
+      2.01  (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2
+      2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG
+      2.00  (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg)
+                         progressive JPEG (stb)
+                         PGM/PPM support (Ken Miller)
+                         STBI_MALLOC,STBI_REALLOC,STBI_FREE
+                         GIF bugfix -- seemingly never worked
+                         STBI_NO_*, STBI_ONLY_*
+      1.48  (2014-12-14) fix incorrectly-named assert()
+      1.47  (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb)
+                         optimize PNG (ryg)
+                         fix bug in interlaced PNG with user-specified channel count (stb)
+      1.46  (2014-08-26)
+              fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG
+      1.45  (2014-08-16)
+              fix MSVC-ARM internal compiler error by wrapping malloc
+      1.44  (2014-08-07)
+              various warning fixes from Ronny Chevalier
+      1.43  (2014-07-15)
+              fix MSVC-only compiler problem in code changed in 1.42
+      1.42  (2014-07-09)
+              don't define _CRT_SECURE_NO_WARNINGS (affects user code)
+              fixes to stbi__cleanup_jpeg path
+              added STBI_ASSERT to avoid requiring assert.h
+      1.41  (2014-06-25)
+              fix search&replace from 1.36 that messed up comments/error messages
+      1.40  (2014-06-22)
+              fix gcc struct-initialization warning
+      1.39  (2014-06-15)
+              fix to TGA optimization when req_comp != number of components in TGA;
+              fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)
+              add support for BMP version 5 (more ignored fields)
+      1.38  (2014-06-06)
+              suppress MSVC warnings on integer casts truncating values
+              fix accidental rename of 'skip' field of I/O
+      1.37  (2014-06-04)
+              remove duplicate typedef
+      1.36  (2014-06-03)
+              convert to header file single-file library
+              if de-iphone isn't set, load iphone images color-swapped instead of returning NULL
+      1.35  (2014-05-27)
+              various warnings
+              fix broken STBI_SIMD path
+              fix bug where stbi_load_from_file no longer left file pointer in correct place
+              fix broken non-easy path for 32-bit BMP (possibly never used)
+              TGA optimization by Arseny Kapoulkine
+      1.34  (unknown)
+              use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case
+      1.33  (2011-07-14)
+              make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements
+      1.32  (2011-07-13)
+              support for "info" function for all supported filetypes (SpartanJ)
+      1.31  (2011-06-20)
+              a few more leak fixes, bug in PNG handling (SpartanJ)
+      1.30  (2011-06-11)
+              added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)
+              removed deprecated format-specific test/load functions
+              removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway
+              error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)
+              fix inefficiency in decoding 32-bit BMP (David Woo)
+      1.29  (2010-08-16)
+              various warning fixes from Aurelien Pocheville
+      1.28  (2010-08-01)
+              fix bug in GIF palette transparency (SpartanJ)
+      1.27  (2010-08-01)
+              cast-to-stbi_uc to fix warnings
+      1.26  (2010-07-24)
+              fix bug in file buffering for PNG reported by SpartanJ
+      1.25  (2010-07-17)
+              refix trans_data warning (Won Chun)
+      1.24  (2010-07-12)
+              perf improvements reading from files on platforms with lock-heavy fgetc()
+              minor perf improvements for jpeg
+              deprecated type-specific functions so we'll get feedback if they're needed
+              attempt to fix trans_data warning (Won Chun)
+      1.23    fixed bug in iPhone support
+      1.22  (2010-07-10)
+              removed image *writing* support
+              stbi_info support from Jetro Lauha
+              GIF support from Jean-Marc Lienher
+              iPhone PNG-extensions from James Brown
+              warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva)
+      1.21    fix use of 'stbi_uc' in header (reported by jon blow)
+      1.20    added support for Softimage PIC, by Tom Seddon
+      1.19    bug in interlaced PNG corruption check (found by ryg)
+      1.18  (2008-08-02)
+              fix a threading bug (local mutable static)
+      1.17    support interlaced PNG
+      1.16    major bugfix - stbi__convert_format converted one too many pixels
+      1.15    initialize some fields for thread safety
+      1.14    fix threadsafe conversion bug
+              header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
+      1.13    threadsafe
+      1.12    const qualifiers in the API
+      1.11    Support installable IDCT, colorspace conversion routines
+      1.10    Fixes for 64-bit (don't use "unsigned long")
+              optimized upsampling by Fabian "ryg" Giesen
+      1.09    Fix format-conversion for PSD code (bad global variables!)
+      1.08    Thatcher Ulrich's PSD code integrated by Nicolas Schulz
+      1.07    attempt to fix C++ warning/errors again
+      1.06    attempt to fix C++ warning/errors again
+      1.05    fix TGA loading to return correct *comp and use good luminance calc
+      1.04    default float alpha is 1, not 255; use 'void *' for stbi_image_free
+      1.03    bugfixes to STBI_NO_STDIO, STBI_NO_HDR
+      1.02    support for (subset of) HDR files, float interface for preferred access to them
+      1.01    fix bug: possible bug in handling right-side up bmps... not sure
+              fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all
+      1.00    interface to zlib that skips zlib header
+      0.99    correct handling of alpha in palette
+      0.98    TGA loader by lonesock; dynamically add loaders (untested)
+      0.97    jpeg errors on too large a file; also catch another malloc failure
+      0.96    fix detection of invalid v value - particleman@mollyrocket forum
+      0.95    during header scan, seek to markers in case of padding
+      0.94    STBI_NO_STDIO to disable stdio usage; rename all #defines the same
+      0.93    handle jpegtran output; verbose errors
+      0.92    read 4,8,16,24,32-bit BMP files of several formats
+      0.91    output 24-bit Windows 3.0 BMP files
+      0.90    fix a few more warnings; bump version number to approach 1.0
+      0.61    bugfixes due to Marc LeBlanc, Christopher Lloyd
+      0.60    fix compiling as c++
+      0.59    fix warnings: merge Dave Moore's -Wall fixes
+      0.58    fix bug: zlib uncompressed mode len/nlen was wrong endian
+      0.57    fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available
+      0.56    fix bug: zlib uncompressed mode len vs. nlen
+      0.55    fix bug: restart_interval not initialized to 0
+      0.54    allow NULL for 'int *comp'
+      0.53    fix bug in png 3->4; speedup png decoding
+      0.52    png handles req_comp=3,4 directly; minor cleanup; jpeg comments
+      0.51    obey req_comp requests, 1-component jpegs return as 1-component,
+              on 'test' only check type, not whether we support this variant
+      0.50  (2006-11-19)
+              first released version
+*/
+
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/