@reversense/dxc-struct 1.0.7

package/index.ts

@@ -0,0 +1,47 @@
+/*
+ *
+ *     Reversense platform / dxc-struct :  Reversense is an automated reverse engineering and analysis platform
+ *     focused on security, privacy, quality, accessibility and safety assessment of software, including mobile app and firmware.
+ *     Copyright (C) 2026  Reversense SAS
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU Affero General Public License as published
+ *     by the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ *
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU Affero General Public License for more details.
+ *
+ *     You should have received a copy of the GNU Affero General Public License
+ *     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+import {StructEncoder} from "./src/StructEncoder.js";
+import {StructDecoder} from "./src/StructDecoder.js";
+import { Struct } from "./src/Struct.js";
+
+[
+    { token:'A', en:StructEncoder.byteArray, de:StructDecoder.byteArray, opts:{ size:1 }},
+    { token:'c', en:StructEncoder.chr, de:StructDecoder.chr, opts:{ size:1 }},
+    { token:'b', en:StructEncoder.int, de:StructDecoder.int, opts:{ size:1, bSigned: true, min: -Math.pow(2, 7), max: Math.pow(2, 7) - 1 }},
+    { token:'B', en:StructEncoder.int, de:StructDecoder.int, opts:{ size:1, bSigned: false, min: 0, max: Math.pow(2, 8) - 1 }},
+    { token:'h', en:StructEncoder.int, de:StructDecoder.int, opts:{ size:2, bSigned: true, min: -Math.pow(2, 15), max: Math.pow(2, 15) - 1 }},
+    { token:'H', en:StructEncoder.int, de:StructDecoder.int, opts:{ size:2, bSigned: false, min: 0, max: Math.pow(2, 16) - 1 }},
+    { token:'s', en:StructEncoder.str, de:StructDecoder.str, opts:{ size:1 }},
+    { token:'S', en:StructEncoder.str, de:StructDecoder.nullTerminatedStr, opts:{ size:1 }},
+    { token:'f', en:StructEncoder.ieee754_fp, de:StructDecoder.ieee754_fp, opts:{ size:4, mLen: 23, rt: Math.pow(2, -24) - Math.pow(2, -77) }},
+    { token:'d', en:StructEncoder.ieee754_fp, de:StructDecoder.ieee754_fp, opts:{ size:8, mLen: 52, rt: 0 }},
+    { token:'i', en:StructEncoder.int, de:StructDecoder.int, opts:{ size:4, bSigned: true, min: -Math.pow(2, 31), max: Math.pow(2, 31) - 1 }},
+    { token:'I', en:StructEncoder.int, de:StructDecoder.int, opts:{ size:4, bSigned: false, min: 0, max: Math.pow(2, 32) - 1 }},
+    { token:'l', en:StructEncoder.int, de:StructDecoder.int, opts:{ size:4, bSigned: true, min: -Math.pow(2, 31), max: Math.pow(2, 31) - 1 }},
+    { token:'L', en:StructEncoder.int, de:StructDecoder.int, opts:{ size:4, bSigned: false, min: 0, max: Math.pow(2, 32) - 1 }},
+    { token:'q', en:StructEncoder.bigintEncoder, de:StructDecoder.bigintDecoder, opts:{ size:8, bSigned: true, min: -Math.pow(2, 63), max: Math.pow(2, 63) - 1 }},
+    { token:'Q', en:StructEncoder.bigintEncoder, de:StructDecoder.bigintDecoder, opts:{ size:8, bSigned: false, min: 0, max: Math.pow(2, 64) - 1 }},
+].map((vOp)=>{
+    Struct.OP[vOp.token] = vOp;
+});
+
+export {Struct};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@reversense/dxc-struct",
+  "version": "1.0.7",
+  "description": "Node equivalent of Python-based Struct library to parse and write binary data.",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "npx tsc",
+    "test": "DEXCALIBUR_TEST=1 mocha -r ts-node/register ./test/**/*.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "ssh://git@github.com:reversenseorg/dxc-struct.git"
+  },
+  "publishConfig": {
+    "@dexcalibur:registry": "https://gitlab.reversense.org/api/v4/projects/63/packages/npm/",
+    "@reversense:registry": "https://registry.npmjs.org/",
+    "@reversenseorg:registry": "https://npm.pkg.github.com/"
+  },
+  "keywords": [
+    "struct",
+    "binary",
+    "data",
+    "parser"
+  ],
+  "type": "module",
+  "author": "Georges-Bastien Michel <georges.michel@reversense.com>",
+  "license": "AGPL-3.0-only",
+  "devDependencies": {
+    "@types/chai": "^4.3.16",
+    "@types/mocha": "^10.0.6",
+    "@types/node": "^20.12.8",
+    "chai": "^5.1.0",
+    "mocha": "^10.4.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  }
+}

package/package.json.bak

@@ -0,0 +1,37 @@
+{
+  "name": "@dexcalibur/dxc-struct",
+  "version": "1.0.7",
+  "description": "Node equivalent of Python-based Struct library to parse and write binary data.",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "npx tsc",
+    "test": "DEXCALIBUR_TEST=1 mocha -r ts-node/register ./test/**/*.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "ssh://git@github.com:reversenseorg/dxc-struct.git"
+  },
+  "publishConfig": {
+    "@dexcalibur:registry": "https://gitlab.reversense.org/api/v4/projects/63/packages/npm/",
+    "@reversense:registry": "https://registry.npmjs.org/",
+    "@reversenseorg:registry": "https://npm.pkg.github.com/"
+  },
+  "keywords": [
+    "struct",
+    "binary",
+    "data",
+    "parser"
+  ],
+  "type": "module",
+  "author": "Georges-Bastien Michel <georges.michel@reversense.com>",
+  "license": "AGPL-3.0-only",
+  "devDependencies": {
+    "@types/chai": "^4.3.16",
+    "@types/mocha": "^10.0.6",
+    "@types/node": "^20.12.8",
+    "chai": "^5.1.0",
+    "mocha": "^10.4.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  }
+}

package/scripts/publish.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+#
+#     Reversense platform / dxc-struct :  Reversense is an automated reverse engineering and analysis platform
+#     focused on security, privacy, quality, accessibility and safety assessment of software, including mobile app and firmware.
+#     Copyright (C) 2026  Reversense SAS
+#
+#     This program is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU Affero General Public License as published
+#     by the Free Software Foundation, either version 3 of the License, or
+#     (at your option) any later version.
+#
+#     This program is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU Affero General Public License for more details.
+#
+#     You should have received a copy of the GNU Affero General Public License
+#     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#
+#
+
+set -e
+
+# Publish npm package within @dexcalibur scope
+npm publish   # use @dexcalibur/<pkg> by default
+
+# Switch scope to ublish npm package within @reversenseorg scope
+cp package.json package.json.bak
+
+npm pkg set name="@reversenseorg/dxc-struct"
+npm publish --registry=https://npm.pkg.github.com/
+
+npm pkg set name="@reversense/dxc-struct"
+npm publish --registry=https://registry.npmjs.org/
+
+mv package.json.bak package.json

package/src/Struct.ts

@@ -0,0 +1,380 @@
+/*
+ *
+ *     Reversense platform / dxc-struct :  Reversense is an automated reverse engineering and analysis platform
+ *     focused on security, privacy, quality, accessibility and safety assessment of software, including mobile app and firmware.
+ *     Copyright (C) 2026  Reversense SAS
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU Affero General Public License as published
+ *     by the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ *
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU Affero General Public License for more details.
+ *
+ *     You should have received a copy of the GNU Affero General Public License
+ *     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+import {RuntimeException} from "./error/RuntimeException.js";
+import {Endianness} from "./common.js";
+
+export type Token = string;
+
+/**
+ * Defines the options available for configuring a transformer.
+ *
+ * @interface TransformerOpts
+ *
+ * @property {number} size
+ * Represents the type size.
+ *
+ * @property {number} [mLen]
+ * Represents the optional mantissa length.
+ *
+ * @property {number} [min]
+ * Specifies the optional minimum value.
+ *
+ * @property {number} [max]
+ * Specifies the optional maximum value.
+ *
+ * @property {number} [rt]
+ * Optional rounding threshold.
+ *
+ * @property {boolean} [bSigned]
+ * Indicates whether to use signed representation.
+ */
+export interface TransformerOpts {
+    // type size
+    size: number,
+    mLen?:number,
+    min?:number,
+    max?:number,
+    rt?:number,
+    bSigned?: boolean
+}
+
+
+export interface Operation {
+    token:Token,
+    en: ((...args:any)=>any),
+    de: ((...args:any)=>any),
+    opts: TransformerOpts
+}
+
+const NOT_NULL_TERM_STRING = 'S';
+export class Struct {
+
+    static NATIVE_ENDIANNESS = Endianness.LITTLE_ENDIAN;
+    /**
+     * Keep it as a global var to replace 'x' by '?'
+     */
+    static PADDING_TOK = 'x';
+    /**
+     * Big-Endian flag
+     *
+     */
+    static BE_FLAG = '<';
+    static OP:Record<Token, Operation> = {};
+
+    // Class data
+    /**
+     * This pattern is designed to match specific sequences of characters that conform
+     * to a set structure. The structure includes the following groups:
+     *
+     * 1. An optional numeric group `(\\d+)?` which captures one or more digits.
+     * 2. A mandatory character group `([AxcbBhHsSfdiIlLqQ])` which captures a single valid
+     *    character from the set: A, x, c, b, B, h, H, s, S, f, d, i, I, l, L, q, Q.
+     * 3. An optional sub-pattern group `(\\(([a-zA-Z0-9]+)\\))?` which captures a
+     *    parenthetical expression containing any combination of letters and digits.
+     *
+     * The FORMAT variable can be used to validate strings, parse strings, or extract
+     * the individual components that match this structure.
+     */
+    static FORMAT = '(\\d+)?([AxcbBhHsSfdiIlLqQ])(\\(([a-zA-Z0-9]+)\\))?';
+
+    /**
+     * A lookup table containing the lengths (in bytes) of various data types.
+     * The keys represent the data type identifiers and the values represent their respective lengths.
+     *
+     * Example Type Identifiers:
+     * - 'A', 'x', 'c', 'b', 'B', 's', 'S': Represent data types with a length of 1 byte.
+     * - 'h', 'H': Represent data types with a length of 2 bytes.
+     * - 'f', 'i', 'I', 'l', 'L': Represent data types with a length of 4 bytes.
+     * - 'd', 'q', 'Q': Represent data types with a length of 8 bytes.
+     */
+    static _lenLut = {'A': 1, 'x': 1, 'c': 1, 'b': 1, 'B': 1, 'h': 2, 'H': 2, 's': 1,
+        'S': 1, 'f': 4, 'd': 8, 'i': 4, 'I': 4, 'l': 4, 'L': 4, 'q': 8, 'Q': 8};
+    /*static _elLut = {
+        's': {en: m._EnString, de: m._DeString},
+        'S': {en: m._EnString, de: m._DeNullString},
+        'b': {en: m._EnInt, de: m._DeInt, len: 1, bSigned: true, min: -Math.pow(2, 7), max: Math.pow(2, 7) - 1},
+        'B': {en: m._EnInt, de: m._DeInt, len: 1, bSigned: false, min: 0, max: Math.pow(2, 8) - 1},
+        'h': {en: m._EnInt, de: m._DeInt, len: 2, bSigned: true, min: -Math.pow(2, 15), max: Math.pow(2, 15) - 1},
+        'H': {en: m._EnInt, de: m._DeInt, len: 2, bSigned: false, min: 0, max: Math.pow(2, 16) - 1},
+        'i': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: true, min: -Math.pow(2, 31), max: Math.pow(2, 31) - 1},
+        'I': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: false, min: 0, max: Math.pow(2, 32) - 1},
+        'l': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: true, min: -Math.pow(2, 31), max: Math.pow(2, 31) - 1},
+        'L': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: false, min: 0, max: Math.pow(2, 32) - 1},
+        'f': {en: m._En754, de: m._De754, len: 4, mLen: 23, rt: Math.pow(2, -24) - Math.pow(2, -77)},
+        'd': {en: m._En754, de: m._De754, len: 8, mLen: 52, rt: 0}
+    };*/
+
+        // Module-level (private) variables
+        // var el,  bBE = false, m = this;
+
+
+
+
+
+        // Unpack a series of n elements of size s from array a at offset p with fxn
+        /**
+         * Unpacks a series of elements from an array, buffer, or string using a specified operation and endian format.
+         *
+         * @param {Endianness} pEndian - The endian format to use when interpreting the data.
+         * @param {Operation} pOpe - The operation defining how elements are decoded.
+         * @param {number} pElCount - The number of elements to unpack.
+         * @param {number} pElSize - The size of each element in bytes.
+         * @param {any[]|Buffer|string} pArr - The input data source (can be an array, buffer, or string).
+         * @param {number} pOffset - The starting offset in the input data source.
+         * @return {any[]} A list of unpacked elements.
+         */
+        static _UnpackSeries(pEndian:Endianness, pOpe:Operation, pElCount:number, pElSize:number,
+                             pArr:any[]|Buffer|string , pOffset:number):any[] {
+            let res:any[] = [];
+            for (let i = 0; i < pElCount; i++){
+                res.push(pOpe.de.apply(null, [pEndian, pOpe, pArr, pOffset+i*pElSize] ))
+            }
+            return res;
+        }
+
+        // Pack a series of n elements of size s from array v at offset i to array a at offset p with fxn
+        /**
+         * Packs a series of elements from a source array or buffer into a destination array or buffer based on the specified endianness, operation, and element size.
+         *
+         * @param {Endianness} pEndian - The endianness to be applied for the operation (e.g., little-endian or big-endian).
+         * @param {Operation} pOp - The operation containing the method to encode the data (e.g., `en` method within the operation object).
+         * @param {number} pElCount - The number of elements to be packed from the source array/buffer.
+         * @param {number} pElSize - The size of each element in bytes.
+         * @param {any[]|Buffer} pDestArr - The destination array or buffer where the packed data will be stored.
+         * @param {number} pOffset - The starting offset in the destination array or buffer where data packing begins.
+         * @param {any[]|Buffer} pSourceArr - The source array or buffer containing elements to be packed.
+         * @param {number} i - The starting index in the source array or buffer from which elements will be read.
+         * @return {void} This method does not return a value; it modifies the destination array or buffer in place.
+         */
+        static _PackSeries(pEndian:Endianness, pOp:Operation, pElCount:number, pElSize:number,
+                           pDestArr:any[]|Buffer, pOffset:number, pSourceArr:any[]|Buffer, i) {
+            for (let  o = 0; o < pElCount; o++){
+                pOp.en.apply(null, [pEndian, pOp, pDestArr, pOffset+o*pElSize, pSourceArr[i+o]])
+            }
+        };
+
+        /**
+         * Combines two arrays, `keys` and `values`, into an object where each key from the `keys` array
+         * is assigned the corresponding value from the `values` array.
+         *
+         * @param {Array} keys - An array containing the keys for the resulting object.
+         * @param {Array} values - An array containing the values corresponding to each key in the `keys` array.
+         * @return {Object} An object constructed by mapping the elements of the `keys` array to the elements of the `values` array.
+         */
+        static _zip(keys, values) {
+            let result:any = {};
+
+            for (var i = 0; i < keys.length; i++) {
+                result[keys[i]] = values[i];
+            }
+
+            return result;
+        }
+
+        // Unpack the octet array a, beginning at offset p, according to the fmt string
+        /**
+         * Unpacks binary data from a buffer, array, or string based on the specified format string.
+         *
+         * @param {string} pFmt The format string defining the structure of the binary data to unpack.
+         *                      It uses format specifiers to describe data types and endianness.
+         * @param {any[]|Buffer|string} pArr The binary data source to unpack. This can be an array, Buffer, or string.
+         * @param {number} [pOffset=0] The starting offset in the data source from where the unpacking should begin.
+         * @return {any} Returns the unpacked data. If keys are defined in the format string, it returns an object; otherwise, it returns an array.
+         */
+        static unpack(pFmt:string, pArr:any[]|Buffer|string, pOffset = 0):any {
+
+            // Set the private bBE flag based on the format string - assume big-endianness
+            let endian = (pFmt.charAt(0) != '<')? Endianness.BIG_ENDIAN:Struct.NATIVE_ENDIANNESS;
+
+            const re = new RegExp(Struct.FORMAT, 'g');
+            let m:RegExpExecArray;
+            let elCount;
+            let elSz = 0;
+            let rk:any[] = [];
+            let rv:any[] = [];
+
+            while (m = re.exec(pFmt)) {
+
+                elCount = ((m[1]==undefined)||(m[1]==''))?1:parseInt(m[1]);
+
+                if(m[2] === NOT_NULL_TERM_STRING) { // Null term string support
+                    elCount = 0; // Need to deal with empty  null term strings
+                    while(pArr[pOffset + elCount] !== 0) {
+                        elCount++;
+                    }
+                    elCount++; // Add one for null byte
+                }
+
+                elSz = Struct.OP[m[2]].opts.size;
+
+                if ((pOffset + elCount*elSz) > pArr.length) {
+                    throw RuntimeException.READ_OOB()
+                }
+
+                if ('SAs'.indexOf(m[2]) != -1) {
+                    rv.push(Struct.OP[m[2]].de(pArr, pOffset, elCount));
+                }
+                else {
+                    rv.push(Struct._UnpackSeries(endian, Struct.OP[m[2]], elCount, elSz, pArr, pOffset));
+                }
+                rk.push(m[4]); // Push key on to array
+
+                pOffset += elCount*elSz;
+            }
+
+            rv = Array.prototype.concat.apply([], rv)
+
+            if(rk.indexOf(undefined) !== -1) {
+                return rv;
+            } else {
+                return Struct._zip(rk, rv);
+            }
+        };
+
+        // Pack the supplied values into the octet array a, beginning at offset p, according to the fmt string
+        /**
+         * Packs data from the source array into the target array or buffer based on the format string.
+         * The format string specifies the data types and layout, controlling how data is serialized
+         * into the provided array or buffer starting from a specific offset.
+         *
+         * @param {string} pFmt - The format string specifying the data layout and types to encode.
+         *                        Data types are represented as tokens (e.g., 's' for string).
+         *                        It may also include prefixes for fixed-size values (e.g., '10s' for a 10-char string).
+         *                        The character '<' at the start specifies little-endian byte order, default is big-endian.
+         * @param {any[]|Buffer} pArr - The target array or buffer where the serialized data will be packed.
+         * @param {number} pStartAt - The offset (in bytes) into the target array or buffer to start packing the data.
+         * @param {any[]} pSource - The source array of values to be packed. The data in this array will follow the layout
+         *                          specified in the format string.
+         * @return {any[]|Buffer} - The modified target array or buffer after packing the serialized data.
+         * @throws {RuntimeException} - Throws if:
+         *                               1. There is not enough space in the target array or buffer to write the data
+         *                                  (buffer overflow).
+         *                               2. Attempted to read data outside the bounds of the source array
+         *                                  (read out of bounds).
+         */
+        static packTo(pFmt:string, pArr:any[]|Buffer, pStartAt:number, pSource:any[]) {
+
+            // Set the private bBE flag based on the format string - assume big-endianness
+            let bigEndian = (pFmt.charAt(0) != '<')? Endianness.BIG_ENDIAN:Struct.NATIVE_ENDIANNESS;
+
+            const re = new RegExp(Struct.FORMAT, 'g');
+            let offset = pStartAt;
+            let m:RegExpExecArray;
+            let sz:number, dataLen:number=0,  i = 0,  j=0;
+            let opType:string;
+
+            while (m = re.exec(pFmt)) {
+
+                // type of data to encode
+                opType = m[2];
+
+                // if data type is prefixed by a counter, such as '10s' (which means a string of 10 chars)
+                dataLen = ((m[1]==undefined)||(m[1]==''))?1:parseInt(m[1]);
+
+                // Null term string support
+                if(opType === NOT_NULL_TERM_STRING) {
+                    // todo : check
+                    dataLen = pSource[i].length + 1; // Add one for null byte
+                }
+
+                sz = Struct.OP[m[2]].opts.size;
+
+                // detect buffer overflow (write out of bound)
+                if ((offset + dataLen*sz) > pArr.length) {
+                    throw RuntimeException.WRITE_OOB();
+                }
+
+                switch (opType) {
+                    // byate array, fixed-length string, null-terminated string
+                    case 'A': case 's': case 'S':
+                        if ((i + 1) > pSource.length) {
+                            throw RuntimeException.READ_OOB();
+                        }
+                        Struct.OP[opType].en(pArr, offset, dataLen, pSource[i]);
+                        i += 1;
+                        break;
+                    case Struct.PADDING_TOK:
+                        for (j = 0; j < dataLen; j++) { pArr[offset+j] = 0; }
+                        break;
+                    default:
+                        if ((i + dataLen) > pSource.length) {
+                            throw RuntimeException.READ_OOB();
+                        }
+                        Struct._PackSeries(bigEndian, Struct.OP[opType], dataLen, sz, pArr, offset, pSource, i);
+                        i += dataLen;
+                        break;
+                }
+                offset += dataLen*sz;
+            }
+
+            return pArr;
+        };
+
+        // Pack the supplied values into a new octet array, according to the fmt string
+        /**
+         *
+         * @param {string} pFmt Format
+         * @param {string} pBinaryData Binary data as string
+         * @return {any}
+         * @method
+         */
+        static pack(pFmt:string, pBinaryData:any[]):any {
+            return Struct.packTo(pFmt, new Buffer(this.calcLength(pFmt, pBinaryData)), 0, pBinaryData);
+        }
+
+        // Determine the number of bytes represented by the format string
+        /**
+         * Calculates the length of a formatted structure based on the provided format string and values.
+         *
+         * @param {string} pFmt - The format string representing the structure layout.
+         *                        It defines how the values map to the structure.
+         * @param {any} pValues - An array or object containing the values to be mapped to the structure format.
+         * @return {number} The total calculated length of the structure in bytes.
+         */
+        static calcLength(pFmt:string, pValues:any):number {
+            const re = new RegExp(Struct.FORMAT, 'g');
+            let m:any,n:number,  sum = 0, i = 0;
+
+            while (m = re.exec(pFmt)) {
+                if((m[1]==undefined)||(m[1]=='')){
+                    n = Struct.OP[m[2]].opts.size; //1
+                }else{
+                    n = parseInt(m[1]) * Struct.OP[m[2]].opts.size;
+                }
+
+                // case of null terminated string => unknow length
+                if(m[2] === NOT_NULL_TERM_STRING) {
+                    n = pValues[i].length + 1; // Add one for null byte
+                }
+
+                // byte counter
+                sum += n;
+
+                // ?
+                if(m[2] !== Struct.PADDING_TOK) {
+                    i++;
+                }
+            }
+            return sum;
+        };
+
+}