diff --git a/CHANGELOG.md b/CHANGELOG.md
index c0a53c48..9b6497a8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,16 @@ All major and minor version changes will be documented in this file. Details of
 
 ## Details
 
+### [10.14.0] - 2024-03-31
+- Added 'To Float' and 'From Float' operations [@tcode2k16] | [#1762]
+- Fix ChaCha raw export option [@joostrijneveld] | [#1606]
+- Update x86 disassembler vendor library [@evanreichard] | [#1197]
+- Allow variable Blowfish key sizes [@cbeuw] | [#933]
+- Added 'XXTEA' operation [@devcydo] | [#1361]
+
+### [10.13.0] - 2024-03-30
+- Added 'FangURL' operation [@breakersall] [@arnydo] | [#1591] [#654]
+
 ### [10.12.0] - 2024-03-29
 - Added 'Salsa20' and 'XSalsa20' operation [@joostrijneveld] | [#1750]
 
@@ -400,6 +410,8 @@ All major and minor version changes will be documented in this file. Details of
 ## [4.0.0] - 2016-11-28
 -  Initial open source commit [@n1474335] | [b1d73a72](https://github.com/gchq/CyberChef/commit/b1d73a725dc7ab9fb7eb789296efd2b7e4b08306)
 
+[10.14.0]: https://github.com/gchq/CyberChef/releases/tag/v10.14.0
+[10.13.0]: https://github.com/gchq/CyberChef/releases/tag/v10.13.0
 [10.12.0]: https://github.com/gchq/CyberChef/releases/tag/v10.12.0
 [10.11.0]: https://github.com/gchq/CyberChef/releases/tag/v10.11.0
 [10.10.0]: https://github.com/gchq/CyberChef/releases/tag/v10.10.0
@@ -571,6 +583,9 @@ All major and minor version changes will be documented in this file. Details of
 [@AshCorr]: https://github.com/AshCorr
 [@simonw]: https://github.com/simonw
 [@chriswhite199]: https://github.com/chriswhite199
+[@breakersall]: https://github.com/breakersall
+[@evanreichard]: https://github.com/evanreichard
+[@devcydo]: https://github.com/devcydo
 
 
 [8ad18b]: https://github.com/gchq/CyberChef/commit/8ad18bc7db6d9ff184ba3518686293a7685bf7b7
@@ -703,3 +718,10 @@ All major and minor version changes will be documented in this file. Details of
 [#1752]: https://github.com/gchq/CyberChef/issues/1752
 [#1753]: https://github.com/gchq/CyberChef/issues/1753
 [#1750]: https://github.com/gchq/CyberChef/issues/1750
+[#1591]: https://github.com/gchq/CyberChef/issues/1591
+[#654]: https://github.com/gchq/CyberChef/issues/654
+[#1762]: https://github.com/gchq/CyberChef/issues/1762
+[#1606]: https://github.com/gchq/CyberChef/issues/1606
+[#1197]: https://github.com/gchq/CyberChef/issues/1197
+[#933]: https://github.com/gchq/CyberChef/issues/933
+[#1361]: https://github.com/gchq/CyberChef/issues/1361
diff --git a/package-lock.json b/package-lock.json
index 701b6f64..122a2990 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "cyberchef",
-  "version": "10.10.0",
+  "version": "10.14.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "cyberchef",
-      "version": "10.10.0",
+      "version": "10.14.0",
       "hasInstallScript": true,
       "license": "Apache-2.0",
       "dependencies": {
@@ -46,6 +46,7 @@
         "flat": "^6.0.1",
         "geodesy": "1.1.3",
         "highlight.js": "^11.9.0",
+        "ieee754": "^1.1.13",
         "jimp": "^0.16.13",
         "jquery": "3.7.1",
         "js-crc": "^0.2.0",
diff --git a/package.json b/package.json
index c77548ca..6e2965f0 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "cyberchef",
-  "version": "10.12.1",
+  "version": "10.14.0",
   "description": "The Cyber Swiss Army Knife for encryption, encoding, compression and data analysis.",
   "author": "n1474335 <n1474335@gmail.com>",
   "homepage": "https://gchq.github.io/CyberChef",
@@ -122,6 +122,7 @@
     "escodegen": "^2.1.0",
     "esprima": "^4.0.1",
     "exif-parser": "^0.1.12",
+    "ieee754": "^1.1.13",
     "fernet": "^0.3.2",
     "file-saver": "^2.0.5",
     "flat": "^6.0.1",
diff --git a/src/core/config/Categories.json b/src/core/config/Categories.json
index 42db30f5..be783119 100644
--- a/src/core/config/Categories.json
+++ b/src/core/config/Categories.json
@@ -14,6 +14,8 @@
             "From Charcode",
             "To Decimal",
             "From Decimal",
+            "To Float",
+            "From Float",
             "To Binary",
             "From Binary",
             "To Octal",
@@ -153,7 +155,8 @@
             "Typex",
             "Lorenz",
             "Colossus",
-            "SIGABA"
+            "SIGABA",
+            "XXTEA"
         ]
     },
     {
@@ -242,6 +245,7 @@
             "Encode NetBIOS Name",
             "Decode NetBIOS Name",
             "Defang URL",
+            "Fang URL",
             "Defang IP Addresses"
         ]
     },
diff --git a/src/core/lib/CipherSaber2.mjs b/src/core/lib/CipherSaber2.mjs
index bf3954e9..8189d961 100644
--- a/src/core/lib/CipherSaber2.mjs
+++ b/src/core/lib/CipherSaber2.mjs
@@ -4,7 +4,7 @@
  * @license Apache-2.0
  */
 export function encode(tempIVP, key, rounds, input) {
-    const ivp = new Uint8Array(key.concat(tempIVP));
+    const ivp = new Uint8Array([...key, ...tempIVP]);
     const state = new Array(256).fill(0);
     let j = 0, i = 0;
     const result = [];
diff --git a/src/core/operations/BlowfishDecrypt.mjs b/src/core/operations/BlowfishDecrypt.mjs
index f7dc8d17..43d6718a 100644
--- a/src/core/operations/BlowfishDecrypt.mjs
+++ b/src/core/operations/BlowfishDecrypt.mjs
@@ -70,10 +70,14 @@ class BlowfishDecrypt extends Operation {
             inputType = args[3],
             outputType = args[4];
 
-        if (key.length !== 8) {
+        if (key.length < 4 || key.length > 56) {
             throw new OperationError(`Invalid key length: ${key.length} bytes
 
-Blowfish uses a key length of 8 bytes (64 bits).`);
+Blowfish's key length needs to be between 4 and 56 bytes (32-448 bits).`);
+        }
+
+        if (iv.length !== 8) {
+            throw new OperationError(`Invalid IV length: ${iv.length} bytes. Expected 8 bytes`);
         }
 
         input = Utils.convertToByteString(input, inputType);
diff --git a/src/core/operations/BlowfishEncrypt.mjs b/src/core/operations/BlowfishEncrypt.mjs
index 2cf3672b..eab3d286 100644
--- a/src/core/operations/BlowfishEncrypt.mjs
+++ b/src/core/operations/BlowfishEncrypt.mjs
@@ -70,10 +70,14 @@ class BlowfishEncrypt extends Operation {
             inputType = args[3],
             outputType = args[4];
 
-        if (key.length !== 8) {
+        if (key.length < 4 || key.length > 56) {
             throw new OperationError(`Invalid key length: ${key.length} bytes
+    
+Blowfish's key length needs to be between 4 and 56 bytes (32-448 bits).`);
+        }
 
-Blowfish uses a key length of 8 bytes (64 bits).`);
+        if (iv.length !== 8) {
+            throw new OperationError(`Invalid IV length: ${iv.length} bytes. Expected 8 bytes`);
         }
 
         input = Utils.convertToByteString(input, inputType);
diff --git a/src/core/operations/ChaCha.mjs b/src/core/operations/ChaCha.mjs
index 166c1663..40ba46dc 100644
--- a/src/core/operations/ChaCha.mjs
+++ b/src/core/operations/ChaCha.mjs
@@ -191,7 +191,7 @@ ChaCha uses a nonce of 8 or 12 bytes (64 or 96 bits).`);
         if (outputType === "Hex") {
             return toHex(output);
         } else {
-            return Utils.arrayBufferToStr(output);
+            return Utils.arrayBufferToStr(Uint8Array.from(output).buffer);
         }
     }
 
diff --git a/src/core/operations/FangURL.mjs b/src/core/operations/FangURL.mjs
new file mode 100644
index 00000000..93e01770
--- /dev/null
+++ b/src/core/operations/FangURL.mjs
@@ -0,0 +1,77 @@
+/**
+ * @author arnydo [github@arnydo.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+
+/**
+ * FangURL operation
+ */
+class FangURL extends Operation {
+
+    /**
+     * FangURL constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Fang URL";
+        this.module = "Default";
+        this.description = "Takes a 'Defanged' Universal Resource Locator (URL) and 'Fangs' it. Meaning, it removes the alterations (defanged) that render it useless so that it can be used again.";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Restore [.]",
+                type: "boolean",
+                value: true
+            },
+            {
+                name: "Restore hxxp",
+                type: "boolean",
+                value: true
+            },
+            {
+                name: "Restore ://",
+                type: "boolean",
+                value: true
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [dots, http, slashes] = args;
+
+        input = fangURL(input, dots, http, slashes);
+
+        return input;
+    }
+
+}
+
+
+/**
+ * Defangs a given URL
+ *
+ * @param {string} url
+ * @param {boolean} dots
+ * @param {boolean} http
+ * @param {boolean} slashes
+ * @returns {string}
+ */
+function fangURL(url, dots, http, slashes) {
+    if (dots) url = url.replace(/\[\.\]/g, ".");
+    if (http) url = url.replace(/hxxp/g, "http");
+    if (slashes) url = url.replace(/\[:\/\/\]/g, "://");
+
+    return url;
+}
+
+export default FangURL;
diff --git a/src/core/operations/FromBase58.mjs b/src/core/operations/FromBase58.mjs
index f5a9ac3d..cb491159 100644
--- a/src/core/operations/FromBase58.mjs
+++ b/src/core/operations/FromBase58.mjs
@@ -60,7 +60,7 @@ class FromBase58 extends Operation {
     run(input, args) {
         let alphabet = args[0] || ALPHABET_OPTIONS[0].value;
         const removeNonAlphaChars = args[1] === undefined ? true : args[1],
-            result = [0];
+            result = [];
 
         alphabet = Utils.expandAlphRange(alphabet).join("");
 
@@ -87,11 +87,9 @@ class FromBase58 extends Operation {
                 }
             }
 
-            let carry = result[0] * 58 + index;
-            result[0] = carry & 0xFF;
-            carry = carry >> 8;
+            let carry = index;
 
-            for (let i = 1; i < result.length; i++) {
+            for (let i = 0; i < result.length; i++) {
                 carry += result[i] * 58;
                 result[i] = carry & 0xFF;
                 carry = carry >> 8;
diff --git a/src/core/operations/FromFloat.mjs b/src/core/operations/FromFloat.mjs
new file mode 100644
index 00000000..4fe5990e
--- /dev/null
+++ b/src/core/operations/FromFloat.mjs
@@ -0,0 +1,78 @@
+/**
+ * @author tcode2k16 [tcode2k16@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+import ieee754 from "ieee754";
+import {DELIM_OPTIONS} from "../lib/Delim.mjs";
+
+/**
+ * From Float operation
+ */
+class FromFloat extends Operation {
+
+    /**
+     * FromFloat constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "From Float";
+        this.module = "Default";
+        this.description = "Convert from EEE754 Floating Point Numbers";
+        this.infoURL = "https://en.wikipedia.org/wiki/IEEE_754";
+        this.inputType = "string";
+        this.outputType = "byteArray";
+        this.args = [
+            {
+                "name": "Endianness",
+                "type": "option",
+                "value": [
+                    "Big Endian",
+                    "Little Endian"
+                ]
+            },
+            {
+                "name": "Size",
+                "type": "option",
+                "value": [
+                    "Float (4 bytes)",
+                    "Double (8 bytes)"
+                ]
+            },
+            {
+                "name": "Delimiter",
+                "type": "option",
+                "value": DELIM_OPTIONS
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    run(input, args) {
+        if (input.length === 0) return [];
+
+        const [endianness, size, delimiterName] = args;
+        const delim = Utils.charRep(delimiterName || "Space");
+        const byteSize = size === "Double (8 bytes)" ? 8 : 4;
+        const isLE = endianness === "Little Endian";
+        const mLen = byteSize === 4 ? 23 : 52;
+        const floats = input.split(delim);
+
+        const output = new Array(floats.length*byteSize);
+        for (let i = 0; i < floats.length; i++) {
+            ieee754.write(output, parseFloat(floats[i]), i*byteSize, isLE, mLen, byteSize);
+        }
+        return output;
+    }
+
+}
+
+export default FromFloat;
diff --git a/src/core/operations/ToBase58.mjs b/src/core/operations/ToBase58.mjs
index 5353c40e..2e71b20e 100644
--- a/src/core/operations/ToBase58.mjs
+++ b/src/core/operations/ToBase58.mjs
@@ -43,7 +43,7 @@ class ToBase58 extends Operation {
     run(input, args) {
         input = new Uint8Array(input);
         let alphabet = args[0] || ALPHABET_OPTIONS[0].value,
-            result = [0];
+            result = [];
 
         alphabet = Utils.expandAlphRange(alphabet).join("");
 
@@ -60,11 +60,9 @@ class ToBase58 extends Operation {
         }
 
         input.forEach(function(b) {
-            let carry = (result[0] << 8) + b;
-            result[0] = carry % 58;
-            carry = (carry / 58) | 0;
+            let carry = b;
 
-            for (let i = 1; i < result.length; i++) {
+            for (let i = 0; i < result.length; i++) {
                 carry += result[i] << 8;
                 result[i] = carry % 58;
                 carry = (carry / 58) | 0;
diff --git a/src/core/operations/ToFloat.mjs b/src/core/operations/ToFloat.mjs
new file mode 100644
index 00000000..b9aef638
--- /dev/null
+++ b/src/core/operations/ToFloat.mjs
@@ -0,0 +1,80 @@
+/**
+ * @author tcode2k16 [tcode2k16@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import ieee754 from "ieee754";
+import {DELIM_OPTIONS} from "../lib/Delim.mjs";
+
+/**
+ * To Float operation
+ */
+class ToFloat extends Operation {
+
+    /**
+     * ToFloat constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "To Float";
+        this.module = "Default";
+        this.description = "Convert to EEE754 Floating Point Numbers";
+        this.infoURL = "https://en.wikipedia.org/wiki/IEEE_754";
+        this.inputType = "byteArray";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Endianness",
+                "type": "option",
+                "value": [
+                    "Big Endian",
+                    "Little Endian"
+                ]
+            },
+            {
+                "name": "Size",
+                "type": "option",
+                "value": [
+                    "Float (4 bytes)",
+                    "Double (8 bytes)"
+                ]
+            },
+            {
+                "name": "Delimiter",
+                "type": "option",
+                "value": DELIM_OPTIONS
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [endianness, size, delimiterName] = args;
+        const delim = Utils.charRep(delimiterName || "Space");
+        const byteSize = size === "Double (8 bytes)" ? 8 : 4;
+        const isLE = endianness === "Little Endian";
+        const mLen = byteSize === 4 ? 23 : 52;
+
+        if (input.length % byteSize !== 0) {
+            throw new OperationError(`Input is not a multiple of ${byteSize}`);
+        }
+
+        const output = [];
+        for (let i = 0; i < input.length; i+=byteSize) {
+            output.push(ieee754.read(input, i, isLE, mLen, byteSize));
+        }
+        return output.join(delim);
+    }
+
+}
+
+export default ToFloat;
diff --git a/src/core/operations/XXTEA.mjs b/src/core/operations/XXTEA.mjs
new file mode 100644
index 00000000..1a0a4368
--- /dev/null
+++ b/src/core/operations/XXTEA.mjs
@@ -0,0 +1,182 @@
+/**
+ * @author devcydo [devcydo@gmail.com]
+ * @author Ma Bingyao [mabingyao@gmail.com]
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import {toBase64} from "../lib/Base64.mjs";
+import Utils from "../Utils.mjs";
+
+/**
+ * XXTEA Encrypt operation
+ */
+class XXTEAEncrypt extends Operation {
+
+    /**
+     * XXTEAEncrypt constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "XXTEA";
+        this.module = "Default";
+        this.description = "Corrected Block TEA (often referred to as XXTEA) is a block cipher designed to correct weaknesses in the original Block TEA. XXTEA operates on variable-length blocks that are some arbitrary multiple of 32 bits in size (minimum 64 bits). The number of full cycles depends on the block size, but there are at least six (rising to 32 for small block sizes). The original Block TEA applies the XTEA round function to each word in the block and combines it additively with its leftmost neighbour. Slow diffusion rate of the decryption process was immediately exploited to break the cipher. Corrected Block TEA uses a more involved round function which makes use of both immediate neighbours in processing each word in the block.";
+        this.infoURL = "https://wikipedia.org/wiki/XXTEA";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Key",
+                "type": "string",
+                "value": "",
+            },
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        let key = args[0];
+
+        if (input === undefined || input === null || input.length === 0) {
+            throw new OperationError("Invalid input length (0)");
+        }
+
+        if (key === undefined || key === null || key.length === 0) {
+            throw new OperationError("Invalid key length (0)");
+        }
+
+        input = Utils.convertToByteString(input, "utf8");
+        key = Utils.convertToByteString(key, "utf8");
+
+        input = this.convertToUint32Array(input, true);
+        key = this.fixLength(this.convertToUint32Array(key, false));
+
+        let encrypted = this.encryptUint32Array(input, key);
+
+        encrypted = toBase64(this.toBinaryString(encrypted, false));
+
+        return encrypted;
+    }
+
+    /**
+     * Convert Uint32Array to binary string
+     *
+     * @param {Uint32Array} v
+     * @param {Boolean} includeLength
+     * @returns {string}
+     */
+    toBinaryString(v, includeLENGTH) {
+        const LENGTH = v.length;
+        let n = LENGTH << 2;
+        if (includeLENGTH) {
+            const M = v[LENGTH - 1];
+            n -= 4;
+            if ((M < n - 3) || (M > n)) {
+                return null;
+            }
+            n = M;
+        }
+        for (let i = 0; i < LENGTH; i++) {
+            v[i] = String.fromCharCode(
+                v[i] & 0xFF,
+                v[i] >>> 8 & 0xFF,
+                v[i] >>> 16 & 0xFF,
+                v[i] >>> 24 & 0xFF
+            );
+        }
+        const RESULT = v.join("");
+        if (includeLENGTH) {
+            return RESULT.substring(0, n);
+        }
+        return RESULT;
+    }
+
+    /**
+     * @param {number} sum
+     * @param {number} y
+     * @param {number} z
+     * @param {number} p
+     * @param {number} e
+     * @param {number} k
+     * @returns {number}
+     */
+    mx(sum, y, z, p, e, k) {
+        return ((z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4)) ^ ((sum ^ y) + (k[p & 3 ^ e] ^ z));
+    }
+
+
+    /**
+     * Encrypt Uint32Array
+     *
+     * @param {Uint32Array} v
+     * @param {number} k
+     * @returns {Uint32Array}
+     */
+    encryptUint32Array(v, k) {
+        const LENGTH = v.length;
+        const N = LENGTH - 1;
+        let y, z, sum, e, p, q;
+        z = v[N];
+        sum = 0;
+        for (q = Math.floor(6 + 52 / LENGTH) | 0; q > 0; --q) {
+            sum = (sum + 0x9E3779B9) & 0xFFFFFFFF;
+            e = sum >>> 2 & 3;
+            for (p = 0; p < N; ++p) {
+                y = v[p + 1];
+                z = v[p] = (v[p] + this.mx(sum, y, z, p, e, k)) & 0xFFFFFFFF;
+            }
+            y = v[0];
+            z = v[N] = (v[N] + this.mx(sum, y, z, N, e, k)) & 0xFFFFFFFF;
+        }
+        return v;
+    }
+
+    /**
+     * Fixes the Uint32Array lenght to 4
+     *
+     * @param {Uint32Array} k
+     * @returns {Uint32Array}
+     */
+    fixLength(k) {
+        if (k.length < 4) {
+            k.length = 4;
+        }
+        return k;
+    }
+
+    /**
+     * Convert string to Uint32Array
+     *
+     * @param {string} bs
+     * @param {Boolean} includeLength
+     * @returns {Uint32Array}
+     */
+    convertToUint32Array(bs, includeLength) {
+        const LENGTH = bs.length;
+        let n = LENGTH >> 2;
+        if ((LENGTH & 3) !== 0) {
+            ++n;
+        }
+        let v;
+        if (includeLength) {
+            v = new Array(n + 1);
+            v[n] = LENGTH;
+        } else {
+            v = new Array(n);
+        }
+        for (let i = 0; i < LENGTH; ++i) {
+            v[i >> 2] |= bs.charCodeAt(i) << ((i & 3) << 3);
+        }
+        return v;
+    }
+
+}
+
+export default XXTEAEncrypt;
diff --git a/src/core/vendor/DisassembleX86-64.mjs b/src/core/vendor/DisassembleX86-64.mjs
index 5f0ac65d..bbaf7a9b 100644
--- a/src/core/vendor/DisassembleX86-64.mjs
+++ b/src/core/vendor/DisassembleX86-64.mjs
@@ -4054,7 +4054,7 @@ function DecodeImmediate( type, BySize, SizeSetting )
     
     //Sign bit adjust.
     
-    if( V32 >= ( n >> 1 ) ) { V32 -= n; }
+    if( V32 >= ( n / 2 ) ) { V32 -= n; }
     
     //Add position.
     
diff --git a/tests/browser/02_ops.js b/tests/browser/02_ops.js
index 7cb0e941..e2b9b28a 100644
--- a/tests/browser/02_ops.js
+++ b/tests/browser/02_ops.js
@@ -126,8 +126,8 @@ module.exports = {
         // testOp(browser, "Extract email addresses", "test input", "test_output");
         // testOp(browser, "Extract file paths", "test input", "test_output");
         testOpFile(browser, "Extract Files", "files/Hitchhikers_Guide.jpeg", ".card:last-child .collapsed", "extracted_at_0x3d38.zlib");
-        testOpFile(browser, "Extract ID3", "files/mp3example.mp3", "tr:last-child td:last-child", "Kevin MacLeod");
-        // testOp(browser, "Extract IP addresses", "test input", "test_output");
+        // This test seems unreliable on GitHub Actions, not reproducible locally.
+        // testOpFile(browser, "Extract ID3", "files/mp3example.mp3", "tr:last-child td:last-child", "Kevin MacLeod");        // testOp(browser, "Extract IP addresses", "test input", "test_output");
         // testOp(browser, "Extract LSB", "test input", "test_output");
         // testOp(browser, "Extract MAC addresses", "test input", "test_output");
         // testOp(browser, "Extract RGBA", "test input", "test_output");
diff --git a/tests/node/tests/operations.mjs b/tests/node/tests/operations.mjs
index 86dbee50..a092ef69 100644
--- a/tests/node/tests/operations.mjs
+++ b/tests/node/tests/operations.mjs
@@ -432,7 +432,7 @@ color: white;
     it("Disassemble x86", () => {
         const result = chef.disassembleX86(chef.toBase64("one two three"));
         const expected = `0000000000000000 0000                            ADD BYTE PTR [RAX],AL\r
-0000000000000002 0B250000000B                    OR ESP,DWORD PTR [0000000-F4FFFFF8]\r
+0000000000000002 0B250000000B                    OR ESP,DWORD PTR [000000000B000008]\r
 `;
         assert.strictEqual(result.toString(), expected);
     }),
diff --git a/tests/operations/index.mjs b/tests/operations/index.mjs
index ed359bc7..9f9be2b7 100644
--- a/tests/operations/index.mjs
+++ b/tests/operations/index.mjs
@@ -62,6 +62,7 @@ import "./tests/DefangIP.mjs";
 import "./tests/ELFInfo.mjs";
 import "./tests/Enigma.mjs";
 import "./tests/ExtractEmailAddresses.mjs";
+import "./tests/Float.mjs";
 import "./tests/FileTree.mjs";
 import "./tests/FletcherChecksum.mjs";
 import "./tests/Fork.mjs";
diff --git a/tests/operations/tests/Base58.mjs b/tests/operations/tests/Base58.mjs
index c23ba9ab..8090b84b 100644
--- a/tests/operations/tests/Base58.mjs
+++ b/tests/operations/tests/Base58.mjs
@@ -53,6 +53,28 @@ TestRegister.addTests([
             },
         ],
     },
+    {
+        name: "To Base58 all null",
+        input: "\0\0\0\0\0\0",
+        expectedOutput: "111111",
+        recipeConfig: [
+            {
+                op: "To Base58",
+                args: ["123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"],
+            },
+        ],
+    },
+    {
+        name: "From Base58 all null",
+        input: "111111",
+        expectedOutput: "\0\0\0\0\0\0",
+        recipeConfig: [
+            {
+                op: "From Base58",
+                args: ["123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"],
+            },
+        ],
+    },
     {
         name: "To Base58 with null prefix and suffix",
         input: "\0\0\0Hello\0\0\0",
diff --git a/tests/operations/tests/ChaCha.mjs b/tests/operations/tests/ChaCha.mjs
index 44b39a67..d194390d 100644
--- a/tests/operations/tests/ChaCha.mjs
+++ b/tests/operations/tests/ChaCha.mjs
@@ -58,6 +58,25 @@ ChaCha uses a nonce of 8 or 12 bytes (64 or 96 bits).`,
             }
         ],
     },
+    {
+        name: "ChaCha: RFC8439 Raw output",
+        input: "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it.",
+        expectedOutput: "6e 2e 35 9a 25 68 f9 80 41 ba 07 28 dd 0d 69 81 e9 7e 7a ec 1d 43 60 c2 0a 27 af cc fd 9f ae 0b f9 1b 65 c5 52 47 33 ab 8f 59 3d ab cd 62 b3 57 16 39 d6 24 e6 51 52 ab 8f 53 0c 35 9f 08 61 d8 07 ca 0d bf 50 0d 6a 61 56 a3 8e 08 8a 22 b6 5e 52 bc 51 4d 16 cc f8 06 81 8c e9 1a b7 79 37 36 5a f9 0b bf 74 a3 5b e6 b4 0b 8e ed f2 78 5e 42 87 4d",
+        recipeConfig: [
+            {
+                "op": "ChaCha",
+                "args": [
+                    {"option": "Hex", "string": "00:01:02:03:04:05:06:07:08:09:0a:0b:0c:0d:0e:0f:10:11:12:13:14:15:16:17:18:19:1a:1b:1c:1d:1e:1f"},
+                    {"option": "Hex", "string": "00:00:00:00:00:00:00:4a:00:00:00:00"},
+                    1, "20", "Raw", "Raw",
+                ]
+            },
+            {
+                "op": "To Hex",
+                "args": []
+            },
+        ],
+    },
     {
         name: "ChaCha: draft-strombergson-chacha-test-vectors-01 TC7.1",
         input: "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
diff --git a/tests/operations/tests/CipherSaber2.mjs b/tests/operations/tests/CipherSaber2.mjs
index dd675d45..9872c7ef 100644
--- a/tests/operations/tests/CipherSaber2.mjs
+++ b/tests/operations/tests/CipherSaber2.mjs
@@ -21,13 +21,16 @@ TestRegister.addTests([
         ],
     },
     {
+        // input taken from https://ciphersaber.gurus.org/
         name: "CipherSaber2 Decrypt",
-        input: "\x5d\xd9\x7f\xeb\x77\x3c\x42\x9d\xfe\x9c\x3b\x21\x63\xbd\x53\x38\x18\x7c\x36\x37",
-        expectedOutput: "helloworld",
+        input: "\x6f\x6d\x0b\xab\xf3\xaa\x67\x19\x03\x15\x30\xed\xb6\x77"  +
+            "\xca\x74\xe0\x08\x9d\xd0\xe7\xb8\x85\x43\x56\xbb\x14\x48\xe3" +
+            "\x7c\xdb\xef\xe7\xf3\xa8\x4f\x4f\x5f\xb3\xfd",
+        expectedOutput: "This is a test of CipherSaber.",
         recipeConfig: [
             {
                 op: "CipherSaber2 Decrypt",
-                args: [{ "option": "Latin1", "string": "test" }, 20],
+                args: [{ "option": "Latin1", "string": "asdfg" }, 1],
             },
         ],
     },
diff --git a/tests/operations/tests/Crypt.mjs b/tests/operations/tests/Crypt.mjs
index 0c424050..69123d66 100644
--- a/tests/operations/tests/Crypt.mjs
+++ b/tests/operations/tests/Crypt.mjs
@@ -1948,4 +1948,38 @@ DES uses a key length of 8 bytes (64 bits).`,
             }
         ],
     },
+    {
+        name: "Blowfish Encrypt with variable key length: CBC, ASCII, 4 bytes",
+        input: "The quick brown fox jumps over the lazy dog.",
+        expectedOutput: "823f337a53ecf121aa9ec1b111bd5064d1d7586abbdaaa0c8fd0c6cc43c831c88bf088ee3e07287e3f36cf2e45f9c7e6",
+        recipeConfig: [
+            {
+                "op": "Blowfish Encrypt",
+                "args": [
+                    {"option": "Hex", "string": "00112233"}, // Key
+                    {"option": "Hex", "string": "0000000000000000"}, // IV
+                    "CBC", // Mode
+                    "Raw", // Input
+                    "Hex" // Output
+                ]
+            }
+        ],
+    },
+    {
+        name: "Blowfish Encrypt with variable key length: CBC, ASCII, 42 bytes",
+        input: "The quick brown fox jumps over the lazy dog.",
+        expectedOutput: "19f5a68145b34321cfba72226b0f33922ce44dd6e7869fe328db64faae156471216f12ed2a37fd0bdd7cebf867b3cff0",
+        recipeConfig: [
+            {
+                "op": "Blowfish Encrypt",
+                "args": [
+                    {"option": "Hex", "string": "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdead"}, // Key
+                    {"option": "Hex", "string": "0000000000000000"}, // IV
+                    "CBC", // Mode
+                    "Raw", // Input
+                    "Hex" // Output
+                ]
+            }
+        ],
+    }
 ]);
diff --git a/tests/operations/tests/Float.mjs b/tests/operations/tests/Float.mjs
new file mode 100644
index 00000000..3977834c
--- /dev/null
+++ b/tests/operations/tests/Float.mjs
@@ -0,0 +1,164 @@
+/**
+ * Float tests.
+ *
+ * @author tcode2k16 [tcode2k16@gmail.com]
+ *
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import TestRegister from "../../lib/TestRegister.mjs";
+
+
+TestRegister.addTests([
+    {
+        name: "To Float: nothing",
+        input: "",
+        expectedOutput: "",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: ["Auto"]
+            },
+            {
+                op: "To Float",
+                args: ["Big Endian", "Float (4 bytes)", "Space"]
+            }
+        ],
+    },
+    {
+        name: "To Float (Big Endian, 4 bytes): 0.5",
+        input: "3f0000003f000000",
+        expectedOutput: "0.5 0.5",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: ["Auto"]
+            },
+            {
+                op: "To Float",
+                args: ["Big Endian", "Float (4 bytes)", "Space"]
+            }
+        ]
+    },
+    {
+        name: "To Float (Little Endian, 4 bytes): 0.5",
+        input: "0000003f0000003f",
+        expectedOutput: "0.5 0.5",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: ["Auto"]
+            },
+            {
+                op: "To Float",
+                args: ["Little Endian", "Float (4 bytes)", "Space"]
+            }
+        ]
+    },
+    {
+        name: "To Float (Big Endian, 8 bytes): 0.5",
+        input: "3fe00000000000003fe0000000000000",
+        expectedOutput: "0.5 0.5",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: ["Auto"]
+            },
+            {
+                op: "To Float",
+                args: ["Big Endian", "Double (8 bytes)", "Space"]
+            }
+        ]
+    },
+    {
+        name: "To Float (Little Endian, 8 bytes): 0.5",
+        input: "000000000000e03f000000000000e03f",
+        expectedOutput: "0.5 0.5",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: ["Auto"]
+            },
+            {
+                op: "To Float",
+                args: ["Little Endian", "Double (8 bytes)", "Space"]
+            }
+        ]
+    },
+    {
+        name: "From Float: nothing",
+        input: "",
+        expectedOutput: "",
+        recipeConfig: [
+            {
+                op: "From Float",
+                args: ["Big Endian", "Float (4 bytes)", "Space"]
+            },
+            {
+                op: "To Hex",
+                args: ["None"]
+            }
+        ]
+    },
+    {
+        name: "From Float (Big Endian, 4 bytes): 0.5",
+        input: "0.5 0.5",
+        expectedOutput: "3f0000003f000000",
+        recipeConfig: [
+            {
+                op: "From Float",
+                args: ["Big Endian", "Float (4 bytes)", "Space"]
+            },
+            {
+                op: "To Hex",
+                args: ["None"]
+            }
+        ]
+    },
+    {
+        name: "From Float (Little Endian, 4 bytes): 0.5",
+        input: "0.5 0.5",
+        expectedOutput: "0000003f0000003f",
+        recipeConfig: [
+            {
+                op: "From Float",
+                args: ["Little Endian", "Float (4 bytes)", "Space"]
+            },
+            {
+                op: "To Hex",
+                args: ["None"]
+            }
+        ]
+    },
+    {
+        name: "From Float (Big Endian, 8 bytes): 0.5",
+        input: "0.5 0.5",
+        expectedOutput: "3fe00000000000003fe0000000000000",
+        recipeConfig: [
+            {
+                op: "From Float",
+                args: ["Big Endian", "Double (8 bytes)", "Space"]
+            },
+            {
+                op: "To Hex",
+                args: ["None"]
+            }
+        ]
+    },
+    {
+        name: "From Float (Little Endian, 8 bytes): 0.5",
+        input: "0.5 0.5",
+        expectedOutput: "000000000000e03f000000000000e03f",
+        recipeConfig: [
+            {
+                op: "From Float",
+                args: ["Little Endian", "Double (8 bytes)", "Space"]
+            },
+            {
+                op: "To Hex",
+                args: ["None"]
+            }
+        ]
+    }
+]);
diff --git a/tests/operations/tests/XXTEA.mjs b/tests/operations/tests/XXTEA.mjs
new file mode 100644
index 00000000..4787f086
--- /dev/null
+++ b/tests/operations/tests/XXTEA.mjs
@@ -0,0 +1,62 @@
+/**
+ * Base64 tests.
+ *
+ * @author devcydo [devcydo@gmail.com]
+ *
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        name: "XXTEA",
+        input: "Hello World! 你好，中国！",
+        expectedOutput: "QncB1C0rHQoZ1eRiPM4dsZtRi9pNrp7sqvX76cFXvrrIHXL6",
+        reecipeConfig: [
+            {
+                args: "1234567890"
+            },
+        ],
+    },
+    {
+        name: "XXTEA",
+        input: "ნუ პანიკას",
+        expectedOutput: "PbWjnbFmP8Apu2MKOGNbjeW/72IZLlLMS/g82ozLxwE=",
+        reecipeConfig: [
+            {
+                args: "1234567890"
+            },
+        ],
+    },
+    {
+        name: "XXTEA",
+        input: "ნუ პანიკას",
+        expectedOutput: "dHrOJ4ClIx6gH33NPSafYR2GG7UqsazY6Xfb0iekBY4=",
+        reecipeConfig: [
+            {
+                args: "ll3kj209d2"
+            },
+        ],
+    },
+    {
+        name: "XXTEA",
+        input: "",
+        expectedOutput: "Invalid input length (0)",
+        reecipeConfig: [
+            {
+                args: "1234567890"
+            },
+        ],
+    },
+    {
+        name: "XXTEA",
+        input: "",
+        expectedOutput: "Invalid input length (0)",
+        reecipeConfig: [
+            {
+                args: ""
+            },
+        ],
+    },
+]);