@reversense/dxc-struct 1.0.7

package/test/Struct.test.ts

@@ -0,0 +1,251 @@
+import * as _path_ from "path";
+import * as _fs_ from "fs";
+import {expect} from "chai";
+import {Struct} from "../dist/index.js";
+
+const ELF_MAGIC : string = '\u007FELF';
+const ELF_MAGIC_ARRAY : number[] = [0x7F, 0x45, 0x4C, 0x46];
+const ELF_HEADER_32B = {
+    'Magic': '\u007FELF',
+    'Class': 1,
+    'Data': 1,
+    'EI_Version': 1,
+    'OS_ABI': 0,
+    'ABI_Version': 0,
+    'Type': 3,
+    'Machine': 40,
+    'Version': 1,
+    'Entry_point_address': 0,
+    'Start_program_headers': 52,
+    'Start_section_headers': 4436,
+    'Flags': 83886080,
+    'Header_size': 52,
+    'Program_headers_size': 32,
+    'number_of_program_headers': 7,
+    'Section_headers_size': 40,
+    'Number_of_section_headers': 20,
+    'Section_header_string_table_index': 19
+};
+// Need to use BigInt to store precisely integers of more than 64 bits.
+const ELF_HEADER_64B = {
+    'Magic': '\u007FELF',
+    'Class': 2, 
+    'Data': 1, 
+    'EI_Version': 1,
+    'OS_ABI': 0, 
+    'ABI_Version': 0, 
+    'Type': 3, 
+    'Machine': 62,
+    'Version': 1,
+    'Entry_point_address': BigInt(79376),
+    'Start_program_headers': BigInt(64),
+    'Start_section_headers': BigInt(844904),
+    'Flags': 0, 
+    'Header_size': 64, 
+    'Program_headers_size': 56, 
+    'number_of_program_headers': 13, 
+    'Section_headers_size': 64, 
+    'Number_of_section_headers': 31,
+    'Section_header_string_table_index': 30
+};
+
+describe('Struct:decoding individual format', function (){
+
+    it('Decoding unsigned byte B', function () {
+        const buf = Buffer.from([0xf3, 0x21, 0x03, 0x00, 0xcd, 0x21, 0x97, 0xff]);
+        const buf_unpack = Struct.unpack('B', buf);
+        expect(buf_unpack[0]).to.equal(buf.readUInt8(0));
+    });
+
+    it('Decoding signed byte B', function () {
+        const buf = Buffer.from([0xf3, 0x21, 0x03, 0x00, 0xcd, 0x21, 0x97, 0xff]);
+        const buf_unpack = Struct.unpack('b', buf);
+        expect(buf_unpack[0]).to.equal(buf.readInt8(0));
+    });
+
+    it('Decoding unsigned int I', function () {
+        const buf = Buffer.from([0xf3, 0x21, 0x03, 0x00, 0xcd, 0x21, 0x97, 0xff]);
+        const buf_unpack = Struct.unpack('>I', buf);
+        expect(buf_unpack[0]).to.equal(buf.readUInt32BE(0));
+    });
+
+    it('Decoding signed int i', function () {
+        const buf = Buffer.from([0xf3, 0x21, 0x03, 0x00, 0xcd, 0x21, 0x97, 0xff]);
+        const buf_unpack = Struct.unpack('>i', buf);
+        expect(buf_unpack[0]).to.equal(buf.readInt32BE(0));
+    });
+
+    it('Decoding unsigned int <I Little Endian', function () {
+        const buf = Buffer.from([0xf3, 0x21, 0x03, 0x00, 0xcd, 0x21, 0x97, 0xff]);
+        const buf_unpack = Struct.unpack('<I', buf);
+        expect(buf_unpack[0]).to.equal(buf.readUInt32LE(0));
+    });
+
+    it('Decoding signed int <i Little Endian', function () {
+        const buf = Buffer.from([0xf3, 0x21, 0x03, 0x00, 0xcd, 0x21, 0x97, 0xff]);
+        const buf_unpack = Struct.unpack('<i', buf);
+        expect(buf_unpack[0]).to.equal(buf.readInt32LE(0));
+    });
+
+    it('Decoding unsigned long L', function () {
+        const buf = Buffer.from([0xf3, 0x21, 0x03, 0x00, 0xcd, 0x21, 0x97, 0xff, 0x33]);
+        const buf_unpack = Struct.unpack('>L', buf);
+        expect(buf_unpack[0]).to.equal(buf.readUInt32BE(0));
+    });
+
+    it('Decoding signed long l', function () {
+        const buf = Buffer.from([0xf3, 0x21, 0x03, 0x00, 0xcd, 0x21, 0x97, 0xff, 0x33]);
+        const buf_unpack = Struct.unpack('>l', buf);
+        expect(buf_unpack[0]).to.equal(buf.readInt32BE(0));
+    });
+
+    it('Decoding unsigned long long Q', function () {
+        const buf = Buffer.from([0xf1, 0x01, 0x03, 0x00, 0x1d, 0x11, 0x17, 0x42, 0x33]);
+        const buf_unpack = Struct.unpack('>Q', buf);
+        expect(buf_unpack[0]).to.equal(buf.readBigUInt64BE(0));
+        // expect(buf_unpack[0]).to.equal(buf.readDoubleBE(0));
+    });
+
+    it('Decoding signed long long q -1', function () {
+        //const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xcd, 0x21, 0x97, 0x00]);
+        //const buf = Buffer.from([0xf3, 0x21, 0x03, 0x00, 0xcd, 0x21, 0x97, 0xff]);
+        const buf = Buffer.from([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x33]);
+        const buf_unpack : bigint[] = Struct.unpack('>q', buf);
+        expect(buf_unpack[0]).to.equal(buf.readBigInt64BE(0));
+    });
+
+    it('Decoding signed long long q Lowest', function () {
+        //const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xcd, 0x21, 0x97, 0x00]);
+        //const buf = Buffer.from([0xf3, 0x21, 0x03, 0x00, 0xcd, 0x21, 0x97, 0xff]);
+        const buf = Buffer.from([0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33]);
+        const buf_unpack : bigint[] = Struct.unpack('>q', buf);
+        expect(buf_unpack[0]).to.equal(buf.readBigInt64BE(0));
+    });
+
+    it('Decoding unsigned long long Q Highest', function () {
+        //const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xcd, 0x21, 0x97, 0x00]);
+        //const buf = Buffer.from([0xf3, 0x21, 0x03, 0x00, 0xcd, 0x21, 0x97, 0xff]);
+        const buf = Buffer.from([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x33]);
+        const buf_unpack: bigint[] = Struct.unpack('>Q', buf);
+        expect(buf_unpack[0]).to.equal(buf.readBigUInt64BE(0));
+    });
+
+    it('False format error', function () {
+        const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
+        const buf_unpack = Struct.unpack('>Z', buf);
+        expect(buf_unpack).to.empty;
+    });
+});
+
+describe('Struct:decoding Elf32 header', function () {
+
+    let BUFFER_1:any;
+
+    before(()=>{
+        BUFFER_1 = _fs_.readFileSync(_path_.join(process.cwd(),'test','res','elf32_lib.so'))
+    });
+
+    describe('Decoding ELF32 Header', function () {
+
+        it('Decoding ELF Magic', function () {
+            const magic : number[] = Struct.unpack('<4s',BUFFER_1);
+            expect(magic[0]).to.eql(ELF_MAGIC);
+        });
+
+        it('Decoding ELF Magic with number in format', function () {
+            const magic_array : number[] = Struct.unpack('<4B',BUFFER_1);
+            expect(magic_array).to.eql(ELF_MAGIC_ARRAY);
+        });
+
+        it('Decoding entire ELF Header', function () {
+            const e_ident = Struct.unpack('<4sBBBBB',BUFFER_1);
+            const e_rest = Struct.unpack('<HHIIIIIHHHHHH',BUFFER_1.subarray(16));
+            const elf_header = {
+                'Magic': e_ident[0],
+                'Class': e_ident[1],
+                'Data': e_ident[2],
+                'EI_Version': e_ident[3],
+                'OS_ABI': e_ident[4],
+                'ABI_Version': e_ident[5],
+                'Type': e_rest[0],
+                'Machine': e_rest[1],
+                'Version': e_rest[2],
+                'Entry_point_address': e_rest[3],
+                'Start_program_headers': e_rest[4],
+                'Start_section_headers': e_rest[5],
+                'Flags': e_rest[6],
+                'Header_size': e_rest[7],
+                'Program_headers_size': e_rest[8],
+                'number_of_program_headers': e_rest[9],
+                'Section_headers_size': e_rest[10],
+                'Number_of_section_headers': e_rest[11],
+                'Section_header_string_table_index': e_rest[12]
+            };
+            expect(elf_header).to.eql(ELF_HEADER_32B);
+        });
+    });
+});
+
+
+describe('Struct:decoding Elf64 header', function() {
+    let BUFFER_2:any;
+    before(()=>{
+        BUFFER_2 = _fs_.readFileSync(_path_.join(process.cwd(),'test','res','elf64_ssh.bin'))
+    });
+
+    describe('Decoding ELF64 Header', function () {
+
+        it('Decoding entire ELF Header', function () {
+            const e_ident = Struct.unpack('<4sBBBBB',BUFFER_2);
+            const e_rest = Struct.unpack('<HHIQQQIHHHHHH',BUFFER_2.subarray(16));
+            const elf64_header = {
+                'Magic': e_ident[0],
+                'Class': e_ident[1],
+                'Data': e_ident[2],
+                'EI_Version': e_ident[3],
+                'OS_ABI': e_ident[4],
+                'ABI_Version': e_ident[5],
+                'Type': e_rest[0],
+                'Machine': e_rest[1],
+                'Version': e_rest[2],
+                'Entry_point_address': e_rest[3],
+                'Start_program_headers': e_rest[4],
+                'Start_section_headers': e_rest[5],
+                'Flags': e_rest[6],
+                'Header_size': e_rest[7],
+                'Program_headers_size': e_rest[8],
+                'number_of_program_headers': e_rest[9],
+                'Section_headers_size': e_rest[10],
+                'Number_of_section_headers': e_rest[11],
+                'Section_header_string_table_index': e_rest[12]
+            };
+            expect(elf64_header).to.eql(ELF_HEADER_64B);
+        });
+    });
+});
+
+
+describe('Struct:decoding', function() {
+
+    let BUFFER_1:any;
+
+    before(()=>{
+        BUFFER_1 = _fs_.readFileSync(_path_.join(process.cwd(),'test','res','resources.arsc'))
+    });
+
+    describe('mixed', function () {
+
+        it('valid format', function () {
+            const data = Struct.unpack('<HHII',BUFFER_1);
+
+            const header = {
+                "Type Signature": data[0],
+                "Header Size": data[1],
+                "File Size": data[2],
+                "Package Count": data[3]
+            }
+            console.log(header);
+            console.log(Struct.calcLength('<HHII',BUFFER_1));
+        });
+    });
+});

package/test/StructDecoder-int.test.ts

@@ -0,0 +1,133 @@
+import {expect} from "chai";
+import {Struct} from "../dist/index.js";
+import {StructDecoder} from '../dist/src/StructDecoder.js';
+import {Endianness} from "../dist/src/common.js";
+
+// Tests sourced from https://github.com/nodejs/node/blob/v22.2.0/test/parallel/test-buffer-readint.js
+
+
+describe('StructDecoder test int formats 8-16-32-64', function () {
+
+    // Test 8-bit integers
+    describe('int8', function () {
+        const pOp = Struct.OP['b'];
+        const data = Buffer.from([0x23, 0xab, 0x7c, 0xef]);
+        let endianness = Endianness.BIG_ENDIAN;
+        it('int8 several readings without offset, BE', () => {
+            expect(StructDecoder.int(endianness, pOp, data, 0)).to.equal(0x23);
+            data[0] = 0xff;
+            expect(StructDecoder.int(endianness, pOp, data, 0)).to.equal(-1);
+            data[0] = 0x87;
+            expect(StructDecoder.int(endianness, pOp, data, 0)).to.equal(-121);
+        });
+
+        it('int8 several readings with offset BE', () => {
+            expect(StructDecoder.int(endianness, pOp, data, 1)).to.equal(-85);
+            expect(StructDecoder.int(endianness, pOp, data, 2)).to.equal(124);
+            expect(StructDecoder.int(endianness, pOp, data, 3)).to.equal(-17);
+        });
+        endianness = Endianness.LITTLE_ENDIAN;
+        it('int8 LE', () => {
+            expect(expect(StructDecoder.int(endianness, pOp, data, 1)).to.equal(-85));
+        });
+    });
+
+    // Test 16-bit integers
+    describe('int16', function () {
+        const pOp = Struct.OP['h'];
+        let data = Buffer.from([0x16, 0x79, 0x65, 0x6e, 0x69, 0x78]);
+        it('int16 several readings with various endianness without offset', () => {
+            it('big endian', () => {
+                expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 0)).to.equal(0x1679);
+            });
+            it('little endian', () => {
+                expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 0)).to.equal(0x7916);
+            });
+            it('other values', () => {
+                data[0] = 0xff;
+                data[1] = 0x80;
+                expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 0)).to.equal(-128);
+                expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 0)).to.equal(-32513);
+            });
+        });
+        data = Buffer.from([0x77, 0x65, 0x65, 0x6e, 0x69, 0x78]);
+        it('int16 several readings with offset BE', () => {
+            expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 0)).to.equal(0x7765);
+            expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 1)).to.equal(0x6565);
+            expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 2)).to.equal(0x656e);
+            expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 3)).to.equal(0x6e69);
+            expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 4)).to.equal(0x6978);
+        });
+        it('int16 several readings with offset LE', () => {
+            expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 0)).to.equal(0x6577);
+            expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 1)).to.equal(0x6565);
+            expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 2)).to.equal(0x6e65);
+            expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 3)).to.equal(0x696e);
+            expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 4)).to.equal(0x7869);
+        });
+    });
+
+    // Test 32-bit integers
+    describe('int32', function () {
+        ['i', 'l'].forEach((pFmt) => {
+            describe(`format ${pFmt}`, function () {
+                const pOp = Struct.OP[pFmt];
+                let data = Buffer.from([0x43, 0x53, 0x16, 0x79, 0x36, 0x17]);
+                it('int32 several readings with various endianness without offset', () => {
+                    it('big endian', () => {
+                        expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 0)).to.equal(0x43531679);
+                    });
+                    it('little endian', () => {
+                        expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 0)).to.equal(0x79165343);
+                    });
+                    it('other values', () => {
+                        data[0] = 0xff;
+                        data[1] = 0xfe;
+                        data[2] = 0xef;
+                        data[3] = 0xfa;
+                        expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 0)).to.equal(-69638);
+                        expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 0)).to.equal(-84934913);
+                    });
+                });
+                data = Buffer.from([0x42, 0xc3, 0x95, 0xa9, 0x36, 0x17]);
+                it('int32 several readings with offset BE', () => {
+                    expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 0)).to.equal(0x42c395a9);
+                    expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 1)).to.equal(-1013601994);
+                    expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 2)).to.equal(-1784072681);
+                });
+                it('int32 several readings with offset LE', () => {
+                    expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 0)).to.equal(-1449802942);
+                    expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 1)).to.equal(917083587);
+                    expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 2)).to.equal(389458325);
+                });
+            });
+        });
+    });
+});
+/*
+//TODO add Out of Bound errors in StructDecoder
+// Unit test for Read Out of Bound
+    }
+
+    describe('OOB', function () {
+        const buffer = [0x21, 0xda, 0x2c, 0x55]//Buffer.alloc(4);
+        const pEndianness = Endianness.BIG_ENDIAN;
+
+        [['b', 'Int8'], ['h', 'Int16BE'], ['i', 'Int32BE']].forEach((fmt) => {
+
+            let pFmt = fmt[0];
+            let bFmt = fmt[1];
+            // Verify that default offset works fine.
+            let pOp = Struct.OP[pFmt];
+            [Infinity, -1, -4294967295].forEach((offset) => {
+                it(`Test OOB with ${offset} in ${pFmt}`, ()=> {
+                    expect(() => StructDecoder.int(pEndianness, pOp, buffer, offset))
+                        .to.throw(RuntimeException.READ_OOB().message);
+                });
+            });
+        });
+    });
+
+
+});
+//   */

package/test/StructDecoder-uint.test.ts

@@ -0,0 +1,104 @@
+import {expect} from "chai";
+import {Struct} from "../dist/index.js";
+import {StructDecoder} from '../dist/src/StructDecoder.js';
+import {Endianness} from "../dist/src/common.js";
+
+
+describe('StructDecoder test uint formats 8-16-32-64', function () {
+
+    // Test 8-bit unsigned integers
+    describe('uint8', function () {
+        const pOp = Struct.OP['B'];
+        const data = Buffer.from([0x23, 0xab, 0x7c, 0xef]);
+        let endianness = Endianness.BIG_ENDIAN;
+        it('uint8 several readings without offset, BE', () => {
+            expect(StructDecoder.int(endianness, pOp, data, 0)).to.equal(0x23);
+            data[0] = 0xff;
+            expect(StructDecoder.int(endianness, pOp, data, 0)).to.equal(255);
+            data[0] = 0x87;
+            expect(StructDecoder.int(endianness, pOp, data, 0)).to.equal(135);
+        });
+
+        it('uint8 several readings with offset BE', () => {
+            expect(StructDecoder.int(endianness, pOp, data, 1)).to.equal(171);
+            expect(StructDecoder.int(endianness, pOp, data, 2)).to.equal(124);
+            expect(StructDecoder.int(endianness, pOp, data, 3)).to.equal(239);
+        });
+        endianness = Endianness.LITTLE_ENDIAN;
+        it('uint8 LE', () => {
+            expect(expect(StructDecoder.int(endianness, pOp, data, 1)).to.equal(171));
+        });
+    });
+
+    // Test 16-bit unsigned integers
+    describe('uint16', function () {
+        const pOp = Struct.OP['H'];
+        let data = Buffer.from([0x16, 0x79, 0x65, 0x6e, 0x69, 0x78]);
+        it('uint16 several readings with various endianness without offset', () => {
+            it('big endian', () => {
+                expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 0)).to.equal(0x1679);
+            });
+            it('little endian', () => {
+                expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 0)).to.equal(0x7916);
+            });
+            it('other values', () => {
+                data[0] = 0xff;
+                data[1] = 0x80;
+                expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 0)).to.equal(65408);
+                expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 0)).to.equal(33023);
+            });
+        });
+        data = Buffer.from([0x77, 0x65, 0x65, 0x6e, 0x69, 0x78]);
+        it('uint16 various reading with offset BE', () => {
+            expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 0)).to.equal(0x7765);
+            expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 1)).to.equal(0x6565);
+            expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 2)).to.equal(0x656e);
+            expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 3)).to.equal(0x6e69);
+            expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 4)).to.equal(0x6978);
+        });
+        it('uint16 various reading with offset LE', () => {
+            expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 0)).to.equal(0x6577);
+            expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 1)).to.equal(0x6565);
+            expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 2)).to.equal(0x6e65);
+            expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 3)).to.equal(0x696e);
+            expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 4)).to.equal(0x7869);
+        });
+    });
+
+    // Test 32-bit unsigned integers
+    describe('uint32', function () {
+        ['I', 'L'].forEach((pFmt) => {
+            describe(`format ${pFmt}`, function () {
+                const pOp = Struct.OP[pFmt];
+                let data = Buffer.from([0x43, 0x53, 0x16, 0x79, 0x36, 0x17]);
+                it('several readings with various endianness without offset', () => {
+                    it('big endian', () => {
+                        expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 0)).to.equal(0x43531679);
+                    });
+                    it('little endian', () => {
+                        expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 0)).to.equal(0x79165343);
+                    });
+                    it('other values', () => {
+                        data[0] = 0xff;
+                        data[1] = 0xfe;
+                        data[2] = 0xef;
+                        data[3] = 0xfa;
+                        expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 0)).to.equal(4294897658);
+                        expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 0)).to.equal(4278188783);
+                    });
+                });
+                data = Buffer.from([0x42, 0xc3, 0x95, 0xa9, 0x36, 0x17]);
+                it('uint32 several readings with offset BE', () => {
+                    expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 0)).to.equal(0x42c395a9);
+                    expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 1)).to.equal(3281365302);
+                    expect(StructDecoder.int(Endianness.BIG_ENDIAN, pOp, data, 2)).to.equal(2510894615);
+                });
+                it('uint32 several readings with offset LE', () => {
+                    expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 0)).to.equal(2845164354);
+                    expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 1)).to.equal(917083587);
+                    expect(StructDecoder.int(Endianness.LITTLE_ENDIAN, pOp, data, 2)).to.equal(389458325);
+                });
+            });
+        });
+    });
+});