public static void __hx_ctor_alphatab_importer_GpxFile(global::alphatab.importer.GpxFile __temp_me58)
 {
     unchecked
     {
         {
         }
     }
 }
        public virtual void readUncompressedBlock(global::haxe.io.Bytes data)
        {
            unchecked
            {
                int sectorSize = 4096;
                int offset     = sectorSize;
                while (((offset + 3) < data.length))
                {
                    int entryType = this.getInteger(data, offset);
                    if ((entryType == 2))
                    {
                        global::alphatab.importer.GpxFile file = new global::alphatab.importer.GpxFile();
                        file.fileName = this.getString(data, (offset + 4), 127);
                        file.fileSize = this.getInteger(data, (offset + 140));
                        bool storeFile = default(bool);
                        if ((this._fileFilter != default(global::haxe.lang.Function)))
                        {
                            storeFile = ((bool)(this._fileFilter.__hx_invoke1_o(default(double), file.fileName)));
                        }
                        else
                        {
                            storeFile = this.defaultFileFilter(file.fileName);
                        }

                        if (storeFile)
                        {
                            this.files.push(file);
                        }

                        int dataPointerOffset = (offset + 148);
                        int sector            = 0;
                        int sectorCount       = 0;
                        global::alphatab.io.BytesArray fileData = default(global::alphatab.io.BytesArray);
                        if (storeFile)
                        {
                            fileData = new global::alphatab.io.BytesArray(new global::haxe.lang.Null <int>(file.fileSize, true));
                        }
                        else
                        {
                            fileData = default(global::alphatab.io.BytesArray);
                        }

                        while (((sector = this.getInteger(data, (dataPointerOffset + (4 * sectorCount++)))) != 0))
                        {
                            offset = (sector * sectorSize);
                            if (storeFile)
                            {
                                fileData.addBytes(data.sub(offset, sectorSize));
                            }
                        }

                        if (storeFile)
                        {
                            int __temp_stmt507 = default(int);
                            {
                                double x = global::System.Math.Min(((double)(file.fileSize)), ((double)(fileData.length)));
                                __temp_stmt507 = ((int)(x));
                            }

                            file.data = global::haxe.io.Bytes.alloc(__temp_stmt507);
                            file.data.blit(0, fileData.getBuffer(), 0, file.data.length);
                        }
                    }

                    offset += sectorSize;
                }
            }
        }
		public virtual   void readUncompressedBlock(global::haxe.io.Bytes data)
		{
			unchecked 
			{
				int sectorSize = 4096;
				int offset = sectorSize;
				while (( ( offset + 3 ) < data.length ))
				{
					int entryType = this.getInteger(data, offset);
					if (( entryType == 2 )) 
					{
						global::alphatab.importer.GpxFile file = new global::alphatab.importer.GpxFile();
						file.fileName = this.getString(data, ( offset + 4 ), 127);
						file.fileSize = this.getInteger(data, ( offset + 140 ));
						bool storeFile = default(bool);
						if (( this._fileFilter != default(global::haxe.lang.Function) )) 
						{
							storeFile = ((bool) (this._fileFilter.__hx_invoke1_o(default(double), file.fileName)) );
						}
						 else 
						{
							storeFile = this.defaultFileFilter(file.fileName);
						}
						
						if (storeFile) 
						{
							this.files.push(file);
						}
						
						int dataPointerOffset = ( offset + 148 );
						int sector = 0;
						int sectorCount = 0;
						global::alphatab.io.BytesArray fileData = default(global::alphatab.io.BytesArray);
						if (storeFile) 
						{
							fileData = new global::alphatab.io.BytesArray(new global::haxe.lang.Null<int>(file.fileSize, true));
						}
						 else 
						{
							fileData = default(global::alphatab.io.BytesArray);
						}
						
						while (( (sector = this.getInteger(data, ( dataPointerOffset + ( 4 * sectorCount++ ) ))) != 0 ))
						{
							offset = ( sector * sectorSize );
							if (storeFile) 
							{
								fileData.addBytes(data.sub(offset, sectorSize));
							}
							
						}
						
						if (storeFile) 
						{
							int __temp_stmt507 = default(int);
							{
								double x = global::System.Math.Min(((double) (file.fileSize) ), ((double) (fileData.length) ));
								__temp_stmt507 = ((int) (x) );
							}
							
							file.data = global::haxe.io.Bytes.alloc(__temp_stmt507);
							file.data.blit(0, fileData.getBuffer(), 0, file.data.length);
						}
						
					}
					
					offset += sectorSize;
				}
				
			}
		}