die-python 0.1.0__cp38-cp38-win_amd64.whl

db/Binary/audio.mp3.2.sg

@@ -0,0 +1,189 @@
+// DIE's signature file
+// Author: Jason Hood <jadoxa@yahoo.com.au>
+/*
+   Ref: http://mpgedit.org/mpgedit/mpeg_format/mpeghdr.htm
+        http://www.codeproject.com/Articles/8295/MPEG-Audio-Frame-Header
+*/
+
+init("audio", "MP3 Audio File");
+
+includeScript("duration");
+
+var MP3 = {
+    aVersion: ["2.5", "2", "1"],
+    aLayer: ["III", "II", "I"],
+    aRatev1: [32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, // Layer III
+        32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, // Layer II
+        32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448
+    ], // Layer I
+    aRatev2: [8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, // Layers III & II
+        32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256
+    ], // Layer I
+    aFreq: [11025, 12000, 8000, // v2.5
+        22050, 24000, 16000, // v2
+        44100, 48000, 32000
+    ], // v1
+    aCh: ["Stereo", "Joint stereo", "Dual mono", "Mono"],
+
+    header: function(nOffset) {
+        // AAAAAAAA AAABBCCD EEEEFFGH IIJJKLMM
+        var nHeader = Binary.readBEDword(nOffset);
+        if ((nHeader & 0xFFE00000) != ~~0xFFE00000) // AAAAAAAAAAA
+        {
+            return null;
+        }
+        var nVer = (nHeader >>> 19) & 3; // BB
+        if (nVer == 1) // reserved
+        {
+            return null;
+        }
+        if (nVer > 1) {
+            --nVer;
+        }
+        var nLayer = (nHeader >>> 17) & 3; // CC
+        if (nLayer == 0) // reserved
+        {
+            return null;
+        }
+        --nLayer;
+        var nBitrateIndex = (nHeader >>> 12) & 15; // EEEE
+        if (nBitrateIndex == 0 || nBitrateIndex == 15) // free/bad
+        {
+            return null;
+        }
+        --nBitrateIndex;
+        var nSamplingIndex = (nHeader >>> 10) & 3; // FF
+        if (nSamplingIndex == 3) // reserved
+        {
+            return null;
+        }
+        var nPadding = (nHeader >>> 9) & 1; // G
+        var nChannelMode = (nHeader >>> 6) & 3; // II
+
+        var nBitrate = nVer == 2 ? this.aRatev1[nLayer * 14 + nBitrateIndex] :
+            this.aRatev2[(nLayer == 2) * 14 + nBitrateIndex];
+        var nFreq = this.aFreq[nVer * 3 + nSamplingIndex];
+        var nTime;
+        if (nLayer == 2) // Layer I
+        {
+            nTime = 384 / nFreq;
+        } else if (nLayer == 1 || nVer == 2) // Layer II or v1,Layer III
+        {
+            nTime = 1152 / nFreq;
+        } else // v2/2.5,Layer III
+        {
+            nTime = 576 / nFreq;
+        }
+        var bVBR = 1;
+        var nVBR = Binary.findString(nOffset, 40, "Xing");
+        if (nVBR == -1) {
+            nVBR = Binary.findString(nOffset, 40, "Info");
+            bVBR = 0;
+        }
+        if (nVBR != -1 && (Binary.readByte(nVBR + 7) & 1)) {
+            nTime *= Binary.readBEDword(nVBR + 8);
+            nOffset = bVBR ? -1 : -2;
+        } else if (Binary.compare("'VBRI'", nOffset + 32)) {
+            nTime *= Binary.readBEDword(nVBR + 46);
+            nOffset = -1;
+        } else {
+            if (nLayer == 2) // Layer I
+            {
+                nOffset += Math.floor(12000 * nBitrate / nFreq + nPadding) * 4;
+            } else {
+                // 125 = 1000/8 = kilobits to bytes
+                nOffset += Math.floor(125 * nBitrate * nTime + nPadding);
+            }
+        }
+        return [this.aVersion[nVer],
+            this.aLayer[nLayer],
+            nBitrate,
+            nFreq,
+            this.aCh[nChannelMode],
+            nTime,
+            nOffset
+        ];
+    }
+}
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    if (Binary.getSize() >= 128) {
+        if (Binary.compare("'TAG'", Binary.getSize() - 128)) {
+            sOptions = "ID3v1";
+        }
+        var nOffset = 0,
+            bID3v2 = 0;
+        if (Binary.compare("'ID3'")) {
+            nOffset = (Binary.readByte(6) << 21) |
+                (Binary.readByte(7) << 14) |
+                (Binary.readByte(8) << 7) |
+                (Binary.readByte(9));
+            nOffset += 10;
+            if (sOptions == "") {
+                sOptions = "ID3v2";
+            } else {
+                sOptions += "&2";
+            }
+            bID3v2 = 1;
+        } else if (Binary.compare("'WAVEfmt '........55", 8)) {
+            nOffset = Binary.findString(50, 50, "data") + 8;
+        }
+        var aResult1, aResult = null;
+        aResult1 = MP3.header(nOffset);
+        if (aResult1 == null) {
+            if (bID3v2) {
+                // There may be some junk between the ID3 tag & the data (Win7
+                // sample music files - C:\Users\Public\Music\Sample Music).
+                // Since the ID3 tag is a fair indicator of an MP3, do a search
+                // for v1,Layer III header.
+                nOffset = Binary.findSignature(nOffset, 768, "FFFB");
+                aResult1 = MP3.header(nOffset);
+            }
+            if (aResult1 == null) {
+                return "";
+            }
+        }
+        if (aResult1[6] > 0) {
+            aResult = MP3.header(aResult1[6]);
+            if (aResult == null) {
+                return "";
+            }
+        }
+        bDetected = true;
+        // Assume version, layer & channels don't change.
+        sVersion = "v" + aResult1[0] + ",Layer " + aResult1[1];
+
+        if (bShowOptions) {
+            var nFrames = 1;
+            var nRateSum = aResult1[2];
+            var nFreqSum = aResult1[3];
+            var nSeconds = aResult1[5];
+            var bVBR = 0,
+                bVF = 0;
+            while (aResult != null) {
+                nFrames++;
+                nRateSum += aResult[2];
+                nFreqSum += aResult[3];
+                nSeconds += aResult[5];
+                if (aResult[2] != aResult1[2]) {
+                    bVBR = 1;
+                }
+                if (aResult[3] != aResult1[3]) {
+                    bVF = 1;
+                }
+                aResult = MP3.header(aResult[6]);
+            }
+            sOptions = sOptions.append(Math.round(nRateSum / nFrames) + "kbps");
+            if (bVBR) {
+                sOptions += "(avg)";
+            }
+            sOptions = sOptions.append(Math.round(nFreqSum / nFrames) + "Hz");
+            if (bVF) {
+                sOptions += "(avg)";
+            }
+            sOptions = sOptions.append(aResult1[4], duration(nSeconds));
+        }
+    }
+
+    return result(bShowType, bShowVersion, bShowOptions);
+}

db/Binary/backup images.1.sg

@@ -0,0 +1,27 @@
+// DIE's signature file
+// Author: hypn0 <hypn0@mail.ru>
+
+init("format", "");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    if (Binary.compare("7ca0932f")) {
+        bDetected = true;
+        sName = "R-Studio image";
+        if (Binary.compare("78da", 0x38) != -1) {
+            sOptions = "compressed (zlib)";
+        }
+    } else if (Binary.compare("'$CAN'")) {
+        switch (Binary.readByte(4)) {
+            case 0xe4:
+                sOptions = "First or single file";
+                break;
+            case 0x60:
+                sOptions = "next file";
+                break;
+        }
+        bDetected = true;
+        sName = "Norton Ghost image";
+    }
+
+    return result(bShowType, bShowVersion, bShowOptions);
+}

db/Binary/bin.AAALogo.1.sg

@@ -0,0 +1,16 @@
+// DIE's signature file
+// Author: Tembo (http://tembolab.pl/products/executable-image-viewer.html)
+
+init("format", "AAA Logo");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    if (Binary.getSize() >= 90) {
+        if (Binary.compare("2CA46774")) {
+            sVersion = "";
+            sOptions = "";
+            bDetected = true;
+        }
+    }
+
+    return result(bShowType, bShowVersion, bShowOptions);
+}

db/Binary/bin.Atari ST.1.sg

@@ -0,0 +1,12 @@
+// DIE's signature file
+// Author: hypn0 <hypn0@mail.ru>
+
+init("format", "Atari ST TOS executable");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    if (Binary.compare("601a0000....................0000")) {
+        bDetected = true;
+    }
+
+    return result(bShowType, bShowVersion, bShowOptions);
+}

db/Binary/bin.Borland TDS.sg

@@ -0,0 +1,14 @@
+// DIE's signature file
+
+init("format", "Borland TLINK Symbol Table");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    if (Binary.compare("FB52")) {
+        sVersion = (Binary.readByte(3) + Binary.readByte(0x2) / 100);
+
+        sOptions = "TDS";
+        bDetected = true;
+    }
+
+    return result(bShowType, bShowVersion, bShowOptions);
+}

db/Binary/bin.GuitarPro.1.sg

@@ -0,0 +1,26 @@
+// DIE's signature file
+// Author: Tembo (http://tembolab.pl/products/executable-image-viewer.html)
+
+init("format", "Guitar Pro");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    if (Binary.getSize() > 31) {
+        if (Binary.compare("'BCFZ'") || Binary.compare("'BCFS'")) {
+            sVersion = "6.x";
+            sName += " Tablature";
+            bDetected = true;
+        } else if (Binary.compare("'GPAR'")) {
+            sVersion = "6.x";
+            sName += " Soundbank";
+            bDetected = true;
+        } else if (Binary.compare("18'FICHIER GUITAR PRO'20")) {
+            sVersion = Binary.getString(0x14, 5);
+            if (sVersion) {
+                sName += " Tablature";
+                bDetected = true;
+            }
+        }
+    }
+
+    return result(bShowType, bShowVersion, bShowOptions);
+}

db/Binary/bin.IDA.1.sg

@@ -0,0 +1,78 @@
+// DIE's signature file
+// Author: LinXP
+// Status: WIP
+
+init("format", "");
+includeScript("zlib");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    if (Binary.getSize() >= 0x20) {
+        if (Binary.compare("'IDA'..0000") && Binary.compare("DDCCBBAA", 0x1A)) {
+            var nVer = Binary.read_uint16(0x1E);
+            sVersion = nVer + ".0";
+            switch (Binary.getString(0, 4)) {
+                case "IDA0":
+                    bDetected = true;
+                    sName = "IDA Database (.IDB)"
+                    break;
+                case "IDA1":
+                    bDetected = true;
+                    sName = "IDA Database for 32-bit binary (.IDB)"
+                    break;
+                case "IDA2":
+                    bDetected = true;
+                    sName = "IDA Database for 64-bit binary (.I64)"
+                    break;
+            }
+            if (bDetected) {
+                switch (nVer) {
+                    case 2:
+                        detect_zlib(Binary, Binary.read_uint32(0x06) + 0x05);
+                        break;
+                    case 3:
+                        detect_zlib(Binary, Binary.read_uint32(0x06) + 0x05);
+                        break;
+                    case 4:
+                        detect_zlib(Binary, Binary.read_uint32(0x06) + 0x05);
+                        break;
+                    case 5:
+                        detect_zlib(Binary, Binary.read_uint32(0x06) + 0x09);
+                        break;
+                    case 6:
+                        detect_zlib(Binary, Binary.read_uint32(0x06) + 0x09);
+                        break;
+                }
+            }
+        } else if (Binary.compare("'IDASGN'")) {
+            bDetected = true;
+            sName = "IDA FLIRT Signature Database (.SIG)"
+            var nVer = Binary.read_uint8(0x06);
+            var nModules = Binary.read_uint16(0x12);
+            var nFlags = Binary.read_uint8(0x10);
+            var nLibNameSz = Binary.read_uint8(0x22);
+            var nLibNameOf = 0x25;
+            sVersion = "v" + nVer;
+            if (!nModules) {
+                nModules = Binary.read_uint32(0x25);
+                nLibNameOf += 4;
+                if (nVer >= 10) { nLibNameOf += 4; }
+            }
+            sOptions = "\"" + Binary.getString(nLibNameOf, nLibNameSz) + "\"";
+
+            if (Binary.isVerbose()) {
+                detect_zlib(Binary, nLibNameOf + nLibNameSz);
+                sOption("modules:" + nModules) // count modules
+                sOption("p:" + Binary.read_uint8(0x7)) // processor id
+                sOption("a:" + Binary.read_uint16(0xE)) // application type
+                sOption("o:" + Binary.read_uint16(0xC)) // os type
+                sOption("f:" + Binary.read_uint32(0x8)) // file format type
+            }
+        } else if (Binary.compare("'IDATIL'")) {
+            bDetected = true;
+            sName = "IDA Type Information List (.TIL)";
+            sOptions = "\"" + Binary.getString(0xF, Binary.read_uint8(0xE)) + "\"";
+        }
+    }
+
+    return result(bShowType, bShowVersion, bShowOptions);
+}

db/Binary/bin.ISO 9660.1.sg

@@ -0,0 +1,13 @@
+// DIE's signature file
+
+init("format", "ISO 9660");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    if (Binary.getSize() > 0x8010) {
+        if (Binary.compare("01'CD001'01", 0x8000)) {
+            bDetected = true;
+        }
+    }
+
+    return result(bShowType, bShowVersion, bShowOptions);
+}

db/Binary/bin.JMDL.1.sg

@@ -0,0 +1,36 @@
+// DIE's signature file
+
+init("format", "Microstation Java (JMDL) Compiled Class");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    if (Binary.getSize() >= 8) {
+        if (Binary.compare("CAFEBEEF")) {
+            var nMinor = Binary.readBEWord(4);
+            var nMajor = Binary.readBEWord(6);
+            if (nMajor) {
+                switch (nMajor) {
+                    case 0x2D:
+                        sVersion = "JDK 1.1";
+                        break;
+                    case 0x2E:
+                        sVersion = "JDK 1.2";
+                        break;
+                    case 0x2F:
+                        sVersion = "JDK 1.3";
+                        break;
+                    case 0x30:
+                        sVersion = "JDK 1.4";
+                        break;
+                }
+
+                if ((nMajor >= 0x2D) && (nMajor <= 0x38)) {
+                    bDetected = true;
+                }
+            }
+        }
+    }
+
+
+    _setLang("Java", bDetected);
+    return result(bShowType, bShowVersion, bShowOptions);
+}

db/Binary/bin.JSC.1.sg

@@ -0,0 +1,87 @@
+// DIE's signature file
+// Author: LinXP
+
+init("format", "JavaScript Compiled/Bytenode (.JSC)");
+
+var VersionHash = [
+    ["11.8.172.17", "4aaade2a", "6e55fcb4"],
+    ["11.3.244.8", "88b331c0", "bc2e4000"],
+    ["10.8.168.25", "22162e5c", "866ceba8"],
+    ["10.2.154.26", "353c3291", "82a06935"],
+    ["9.6.180.15", "96a2e9d1", "77a0eea2"],
+    ["9.6.180.14", "efecf234", "15e726e8"],
+    ["9.5.172.25", "87f3c490", "7845cebc"],
+    ["9.5.172.21", "22b0877a", "d54c6bc9"],
+    ["9.4.146.26", "4f3466a4", "ee64ddac"],
+    ["9.4.146.24", "34bdcb66", "251899cd"],
+    ["9.4.146.19", "1c8f8b6a", "15375929"],
+    ["8.6.395.17", "4e4909d8", "a8d671f0"],
+    ["8.6.395.16", "2e933797", "42ff7bd2"],
+    ["8.4.371.23", "422a9510", "305d5cb4"],
+    ["8.4.371.19", "9ee57fe0", "8b279ced"],
+    ["8.3.110.9", "98545131", "878c72a5"],
+    ["8.1.307.31", "2cb9ba58", "8912ed09"],
+    ["8.1.307.30", "22d2f67c", "f8e02587"],
+    ["7.9.317.25", "e46e0ba2", "affe52ff"],
+    ["7.9.317.23", "327e22f1", "a5ef90cb"],
+    ["7.8.279.23", "f4ca7648", "2453843a"],
+    ["7.8.279.17", "533dd511", "2e4f9afd"],
+    ["7.7.299.13", "7ee98716", "8f1d647f"],
+    ["7.7.299.11", "f4bd9236", "defcacc7"],
+    ["7.6.303.29", "62a5311c", "905e664f"],
+    ["7.4.288.27", "8d2f9651", "84fec91f"],
+    ["7.5.288.22", "8176065f", "8b9ea960"],
+    ["7.4.288.21", "4e79ebb1", "27f6dd21"],
+    ["7.0.276.38", "5aa2a8c8", "261396d3"],
+    ["7.0.276.32", "302bcaf2", "1c3c201f"],
+    ["6.8.275.32", "4914c00b", "8af4d4f4"],
+    ["6.8.275.30", "34fd59c5", "91d1cc59"],
+    ["6.8.275.24", "70ff0c52", "74a2eeac"],
+    ["6.7.288.49", "f5e4a619", "aa47d109"],
+    ["6.7.288.46", "555f09bb", "6070752b"],
+    ["6.7.288.45", "3f06ef23", "ca0b678f"],
+    ["6.7.288.43", "bc67142f", "884dad18"],
+    ["6.6.346.32", "9ac1441d", "600024b1"],
+    ["6.6.346.27", "741c5f3b", "91b8852b"],
+    ["6.6.346.24", "cbb74c67", "3e6b9b38"],
+    ["6.2.414.78", "4d9d4c8d", "c2f91993"],
+    ["6.2.414.77", "2e12ba35", "818125c8"],
+    ["6.2.414.72", "90a269a0", "96890b15"],
+    ["6.2.414.66", "a8f60b85", "36eba645"],
+    ["6.2.414.54", "6ed53280", "82f11b7d"],
+    ["6.2.414.50", "ae6544a8", "bd692ce0"],
+    ["6.2.414.46", "4e617339", "81adf054"],
+    ["6.2.414.44", "c60a7c87", "7e207921"],
+    ["6.2.414.32", "42110b24", "84d039aa"],
+    ["6.1.534.50", "a0f6f0f4", "9e10b69f"],
+    ["6.1.534.48", "f14f22a0", "82467775"],
+    ["6.1.534.47", "79276eb0", "221a8fc5"],
+    ["6.1.534.46", "babe69a4", "64318412"],
+    ["6.1.534.42", "166f25d9", "9892d1c2"],
+    ["6.0.287.53", "a1bc32d4", "6fcdcd18"],
+    ["6.0.286.52", "2cf4293d", "a030b731"],
+    ["5.5.372.43", "b96063d0", "c10a0c40"],
+    ["5.1.281.111", "bb23baab", "78f44bee"],
+    ["4.6.85.32", "35a37732", "ca4b83fd"],
+    ["4.5.103.53", "15953e0e", "b217e70b"],
+    ["3.28.71.20", "26145e77", "fec9a40d"],
+];
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    if (Binary.getSize() >= 0x20) {
+        if (Binary.compare("DEC0", 0x02)) {
+            bDetected = true;
+            for (i = 0; i < VersionHash.length; i++) {
+                if (Binary.compare(VersionHash[i][1], 0x04)) {
+                    sVersion = "v" + VersionHash[i][0] + " x86"
+                } else if (Binary.compare(VersionHash[i][2], 0x04)) {
+                    sVersion = "v" + VersionHash[i][0] + " x64"
+                };
+            }
+        }
+    }
+
+
+    _setLang("JavaScript", bDetected);
+    return result(bShowType, bShowVersion, bShowOptions);
+}

db/Binary/bin.Java.1.sg

@@ -0,0 +1,141 @@
+// DIE's signature file
+// Author: Levis <levintaeyeon@live.com>, LinXP
+// doc-ref: https://docs.oracle.com/javase/specs/jvms/se18/html/jvms-4.html
+init("format", "Java Class File (.CLASS)");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    if (Binary.getSize() >= 8) {
+        if (Binary.compare("CAFEBABE")) {
+            var nMinor = Binary.read_uint16(0x04, _BE);
+            var nMajor = Binary.read_uint16(0x06, _BE);
+            bDetected = true;
+            switch (nMajor) {
+                case 45:
+                    sVersion = "JDK 1.1";
+                    break; // February 1997
+                case 46:
+                    sVersion = "JDK 1.2";
+                    break; // December 1998
+                case 47:
+                    sVersion = "JDK 1.3";
+                    break; // May 2000
+                case 48:
+                    sVersion = "JDK 1.4";
+                    break; // February 2002
+                case 49:
+                    sVersion = "Java SE 5.0";
+                    break; // September 2004
+                case 50:
+                    sVersion = "Java SE 6";
+                    break; // December 2006
+                case 51:
+                    sVersion = "Java SE 7";
+                    break; // July 2011
+                case 52:
+                    sVersion = "Java SE 8";
+                    break; // March 2014
+                case 53:
+                    sVersion = "Java SE 9";
+                    break; // September 2017
+                case 54:
+                    sVersion = "Java SE 10";
+                    break; // March 2018
+                case 55:
+                    sVersion = "Java SE 11";
+                    break; // September 2018
+                case 56:
+                    sVersion = "Java SE 12";
+                    break; // March 2019
+                case 57:
+                    sVersion = "Java SE 13";
+                    break; // September 2019
+                case 58:
+                    sVersion = "Java SE 14";
+                    break; // March 2020
+                case 59:
+                    sVersion = "Java SE 15";
+                    break; // September 2020
+                case 60:
+                    sVersion = "Java SE 16";
+                    break; // March 2021
+                case 61:
+                    sVersion = "Java SE 17";
+                    break; // September 2021
+                case 62:
+                    sVersion = "Java SE 18";
+                    break; // March 2022
+                case 63:
+                    sVersion = "Java SE 19";
+                    break; // September 2022
+                case 64:
+                    sVersion = "Java SE 20";
+                    break; // March 2023
+                case 65:
+                    sVersion = "Java SE 21";
+                    break; // September 2023
+                default:
+                    bDetected = false;
+            }
+
+            if ((sVersion != "") && (nMinor)) {
+                sVersion += "." + nMinor;
+            }
+
+            if (bDetected && Binary.isVerbose()) {
+                var nOffset = 0x08;
+                var constant_pool_count = Binary.read_uint16(nOffset, _BE);
+                nOffset += 2;
+                for (pool = 1; pool < constant_pool_count; pool++) {
+                    switch (Binary.read_uint8(nOffset)) // Tag
+                    {
+                        case 1: // CONSTANT_Utf8
+                            nOffset += 1 + 2 + Binary.read_uint16(nOffset + 1, _BE);
+                            break;
+                        case 3: // CONSTANT_Integer
+                        case 4: // CONSTANT_Float
+                            nOffset += 1 + 4;
+                            break;
+                        case 5: // CONSTANT_Long
+                        case 6: // CONSTANT_Double
+                            nOffset += 1 + 4 + 4;
+                            break;
+                        case 7: // CONSTANT_Class
+                        case 8: // CONSTANT_String
+                        case 16: // CONSTANT_MethodType
+                            nOffset += 1 + 2;
+                            break;
+                        case 9: // CONSTANT_Fieldref
+                        case 10: // CONSTANT_Methodref
+                        case 11: // CONSTANT_InterfaceMethodref
+                        case 12: // CONSTANT_NameAndType
+                        case 18: // CONSTANT_InvokeDynamic
+                            nOffset += 1 + 2 + 2;
+                            break;
+                        case 15: // CONSTANT_MethodHandle_info
+                            nOffset += 1 + 1 + 2;
+                            break;
+                        default:
+                            sOption("err unk tag:" + nOffset);
+                    }
+                }
+                var nAccessFlagss = Binary.read_uint16(nOffset, _BE);
+                if (nAccessFlagss & 0x0001) { sOption("ACC_PUBLIC"); }
+                if (nAccessFlagss & 0x0002) { sOption("ACC_PRIVATE"); }
+                if (nAccessFlagss & 0x0004) { sOption("ACC_PROTECTED"); }
+                if (nAccessFlagss & 0x0008) { sOption("ACC_STATIC"); }
+                if (nAccessFlagss & 0x0010) { sOption("ACC_FINAL"); }
+                if (nAccessFlagss & 0x0020) { sOption("ACC_SUPER"); }
+                if (nAccessFlagss & 0x0040) { sOption("ACC_VOLATILE"); }
+                if (nAccessFlagss & 0x0080) { sOption("ACC_TRANSIENT"); }
+                if (nAccessFlagss & 0x0100) { sOption("ACC_NATIVE"); }
+                if (nAccessFlagss & 0x0200) { sOption("ACC_INTERFACE"); }
+                if (nAccessFlagss & 0x0400) { sOption("ACC_ABSTRACT"); }
+                if (nAccessFlagss & 0x0800) { sOption("ACC_STRICT"); }
+            }
+        }
+    }
+
+
+    _setLang("Java", bDetected);
+    return result(bShowType, bShowVersion, bShowOptions);
+}