/**
 * Absolute value. abs(a)==a if a>=0. abs(a)==-a if a<0
 *
 * @param a
 *
 * @returns The absolute value of a
 */
function abs(a) {
    return (a >= 0) ? a : -a;
}

/**
 * Returns the bitlength of a number
 *
 * @param a
 * @returns The bit length
 */
function bitLength(a) {
    if (typeof a === 'number')
        a = BigInt(a);
    if (a === 1n) {
        return 1;
    }
    let bits = 1;
    do {
        bits++;
    } while ((a >>= 1n) > 1n);
    return bits;
}

/**
 * An iterative implementation of the extended euclidean algorithm or extended greatest common divisor algorithm.
 * Take positive integers a, b as input, and return a triple (g, x, y), such that ax + by = g = gcd(a, b).
 *
 * @param a
 * @param b
 *
 * @throws {RangeError}
 * This excepction is thrown if a or b are less than 0
 *
 * @returns A triple (g, x, y), such that ax + by = g = gcd(a, b).
 */
function eGcd(a, b) {
    if (typeof a === 'number')
        a = BigInt(a);
    if (typeof b === 'number')
        b = BigInt(b);
    if (a <= 0n || b <= 0n)
        throw new RangeError('a and b MUST be > 0'); // a and b MUST be positive
    let x = 0n;
    let y = 1n;
    let u = 1n;
    let v = 0n;
    while (a !== 0n) {
        const q = b / a;
        const r = b % a;
        const m = x - (u * q);
        const n = y - (v * q);
        b = a;
        a = r;
        x = u;
        y = v;
        u = m;
        v = n;
    }
    return {
        g: b,
        x: x,
        y: y
    };
}

/**
 * Greatest-common divisor of two integers based on the iterative binary algorithm.
 *
 * @param a
 * @param b
 *
 * @returns The greatest common divisor of a and b
 */
function gcd(a, b) {
    let aAbs = (typeof a === 'number') ? BigInt(abs(a)) : abs(a);
    let bAbs = (typeof b === 'number') ? BigInt(abs(b)) : abs(b);
    if (aAbs === 0n) {
        return bAbs;
    }
    else if (bAbs === 0n) {
        return aAbs;
    }
    let shift = 0n;
    while (((aAbs | bAbs) & 1n) === 0n) {
        aAbs >>= 1n;
        bAbs >>= 1n;
        shift++;
    }
    while ((aAbs & 1n) === 0n)
        aAbs >>= 1n;
    do {
        while ((bAbs & 1n) === 0n)
            bAbs >>= 1n;
        if (aAbs > bAbs) {
            const x = aAbs;
            aAbs = bAbs;
            bAbs = x;
        }
        bAbs -= aAbs;
    } while (bAbs !== 0n);
    // rescale
    return aAbs << shift;
}

/**
 * The least common multiple computed as abs(a*b)/gcd(a,b)
 * @param a
 * @param b
 *
 * @returns The least common multiple of a and b
 */
function lcm(a, b) {
    if (typeof a === 'number')
        a = BigInt(a);
    if (typeof b === 'number')
        b = BigInt(b);
    if (a === 0n && b === 0n)
        return BigInt(0);
    return abs(a * b) / gcd(a, b);
}

/**
 * Maximum. max(a,b)==a if a>=b. max(a,b)==b if a<=b
 *
 * @param a
 * @param b
 *
 * @returns Maximum of numbers a and b
 */
function max(a, b) {
    return (a >= b) ? a : b;
}

/**
 * Minimum. min(a,b)==b if a>=b. min(a,b)==a if a<=b
 *
 * @param a
 * @param b
 *
 * @returns Minimum of numbers a and b
 */
function min(a, b) {
    return (a >= b) ? b : a;
}

/**
 * Finds the smallest positive element that is congruent to a in modulo n
 *
 * @remarks
 * a and b must be the same type, either number or bigint
 *
 * @param a - An integer
 * @param n - The modulo
 *
 * @throws {RangeError}
 * Excpeption thrown when n is not > 0
 *
 * @returns A bigint with the smallest positive representation of a modulo n
 */
function toZn(a, n) {
    if (typeof a === 'number')
        a = BigInt(a);
    if (typeof n === 'number')
        n = BigInt(n);
    if (n <= 0n) {
        throw new RangeError('n must be > 0');
    }
    const aZn = a % n;
    return (aZn < 0n) ? aZn + n : aZn;
}

/**
 * Modular inverse.
 *
 * @param a The number to find an inverse for
 * @param n The modulo
 *
 * @throws {RangeError}
 * Excpeption thorwn when a does not have inverse modulo n
 *
 * @returns The inverse modulo n
 */
function modInv(a, n) {
    const egcd = eGcd(toZn(a, n), n);
    if (egcd.g !== 1n) {
        throw new RangeError(`${a.toString()} does not have inverse modulo ${n.toString()}`); // modular inverse does not exist
    }
    else {
        return toZn(egcd.x, n);
    }
}

/**
 * Modular exponentiation b**e mod n. Currently using the right-to-left binary method
 *
 * @param b base
 * @param e exponent
 * @param n modulo
 *
 * @throws {RangeError}
 * Excpeption thrown when n is not > 0
 *
 * @returns b**e mod n
 */
function modPow(b, e, n) {
    if (typeof b === 'number')
        b = BigInt(b);
    if (typeof e === 'number')
        e = BigInt(e);
    if (typeof n === 'number')
        n = BigInt(n);
    if (n <= 0n) {
        throw new RangeError('n must be > 0');
    }
    else if (n === 1n) {
        return 0n;
    }
    b = toZn(b, n);
    if (e < 0n) {
        return modInv(modPow(b, abs(e), n), n);
    }
    let r = 1n;
    while (e > 0) {
        if ((e % 2n) === 1n) {
            r = r * b % n;
        }
        e = e / 2n;
        b = b ** 2n % n;
    }
    return r;
}

function fromBuffer(buf) {
    let ret = 0n;
    for (const i of buf.values()) {
        const bi = BigInt(i);
        ret = (ret << 8n) + bi;
    }
    return ret;
}

/**
 * Secure random bytes for both node and browsers. Node version uses crypto.randomBytes() and browser one self.crypto.getRandomValues()
 *
 * @param byteLength - The desired number of random bytes
 * @param forceLength - If we want to force the output to have a bit length of 8*byteLength. It basically forces the msb to be 1
 *
 * @throws {RangeError}
 * byteLength MUST be > 0
 *
 * @returns A promise that resolves to a UInt8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bytes
 */
function randBytes(byteLength, forceLength = false) {
    if (byteLength < 1)
        throw new RangeError('byteLength MUST be > 0');
    return new Promise(function (resolve, reject) {
        { // browser
            const buf = new Uint8Array(byteLength);
            self.crypto.getRandomValues(buf);
            // If fixed length is required we put the first bit to 1 -> to get the necessary bitLength
            if (forceLength)
                buf[0] = buf[0] | 128;
            resolve(buf);
        }
    });
}
/**
 * Secure random bytes for both node and browsers. Node version uses crypto.randomFill() and browser one self.crypto.getRandomValues()
 *
 * @param byteLength - The desired number of random bytes
 * @param forceLength - If we want to force the output to have a bit length of 8*byteLength. It basically forces the msb to be 1
 *
 * @throws {RangeError}
 * byteLength MUST be > 0
 *
 * @returns A UInt8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bytes
 */
function randBytesSync(byteLength, forceLength = false) {
    if (byteLength < 1)
        throw new RangeError('byteLength MUST be > 0');
    /* eslint-disable no-lone-blocks */
    { // browser
        const buf = new Uint8Array(byteLength);
        self.crypto.getRandomValues(buf);
        // If fixed length is required we put the first bit to 1 -> to get the necessary bitLength
        if (forceLength)
            buf[0] = buf[0] | 128;
        return buf;
    }
    /* eslint-enable no-lone-blocks */
}

/**
 * Secure random bits for both node and browsers. Node version uses crypto.randomFill() and browser one self.crypto.getRandomValues()
 *
 * @param bitLength - The desired number of random bits
 * @param forceLength - If we want to force the output to have a specific bit length. It basically forces the msb to be 1
 *
 * @throws {RangeError}
 * bitLength MUST be > 0
 *
 * @returns A Promise that resolves to a UInt8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bits
 */
function randBits(bitLength, forceLength = false) {
    if (bitLength < 1)
        throw new RangeError('bitLength MUST be > 0');
    const byteLength = Math.ceil(bitLength / 8);
    const bitLengthMod8 = bitLength % 8;
    return new Promise((resolve, reject) => {
        randBytes(byteLength, false).then(function (rndBytes) {
            if (bitLengthMod8 !== 0) {
                // Fill with 0's the extra bits
                rndBytes[0] = rndBytes[0] & (2 ** bitLengthMod8 - 1);
            }
            if (forceLength) {
                const mask = (bitLengthMod8 !== 0) ? 2 ** (bitLengthMod8 - 1) : 128;
                rndBytes[0] = rndBytes[0] | mask;
            }
            resolve(rndBytes);
        });
    });
}
/**
 * Secure random bits for both node and browsers. Node version uses crypto.randomFill() and browser one self.crypto.getRandomValues()
 * @param bitLength - The desired number of random bits
 * @param forceLength - If we want to force the output to have a specific bit length. It basically forces the msb to be 1
 *
 * @throws {RangeError}
 * bitLength MUST be > 0
 *
 * @returns A Uint8Array/Buffer (Browser/Node.js) filled with cryptographically secure random bits
 */
function randBitsSync(bitLength, forceLength = false) {
    if (bitLength < 1)
        throw new RangeError('bitLength MUST be > 0');
    const byteLength = Math.ceil(bitLength / 8);
    const rndBytes = randBytesSync(byteLength, false);
    const bitLengthMod8 = bitLength % 8;
    if (bitLengthMod8 !== 0) {
        // Fill with 0's the extra bits
        rndBytes[0] = rndBytes[0] & (2 ** bitLengthMod8 - 1);
    }
    if (forceLength) {
        const mask = (bitLengthMod8 !== 0) ? 2 ** (bitLengthMod8 - 1) : 128;
        rndBytes[0] = rndBytes[0] | mask;
    }
    return rndBytes;
}

/**
 * Returns a cryptographically secure random integer between [min,max]. Both numbers must be >=0
 * @param max Returned value will be <= max
 * @param min Returned value will be >= min
 *
 * @throws {RangeError}
 * Arguments MUST be: max > 0 && min >=0 && max > min
 *
 * @returns A cryptographically secure random bigint between [min,max]
 */
function randBetween(max, min = 1n) {
    if (max <= 0n || min < 0n || max <= min)
        throw new RangeError('Arguments MUST be: max > 0 && min >=0 && max > min');
    const interval = max - min;
    const bitLen = bitLength(interval);
    let rnd;
    do {
        const buf = randBitsSync(bitLen);
        rnd = fromBuffer(buf);
    } while (rnd > interval);
    return rnd + min;
}

function _workerUrl(workerCode) {
    workerCode = `(() => {${workerCode}})()`; // encapsulate IIFE
    const _blob = new Blob([workerCode], { type: 'text/javascript' });
    return window.URL.createObjectURL(_blob);
}
let _useWorkers = false; // The following is just to check whether we can use workers
/* eslint-disable no-lone-blocks */
{ // Native JS
    if (self.Worker !== undefined)
        _useWorkers = true;
}

/**
 * The test first tries if any of the first 250 small primes are a factor of the input number and then passes several
 * iterations of Miller-Rabin Probabilistic Primality Test (FIPS 186-4 C.3.1)
 *
 * @param w - A positive integer to be tested for primality
 * @param iterations - The number of iterations for the primality test. The value shall be consistent with Table C.1, C.2 or C.3
 * @param disableWorkers - Disable the use of workers for the primality test
 *
 * @throws {RangeError}
 * w MUST be >= 0
 *
 * @returns A promise that resolves to a boolean that is either true (a probably prime number) or false (definitely composite)
 */
function isProbablyPrime(w, iterations = 16, disableWorkers = false) {
    if (typeof w === 'number') {
        w = BigInt(w);
    }
    if (w < 0n)
        throw RangeError('w MUST be >= 0');
    { // browser
        return new Promise((resolve, reject) => {
            const worker = new Worker(_isProbablyPrimeWorkerUrl());
            worker.onmessage = (event) => {
                worker.terminate();
                resolve(event.data.isPrime);
            };
            worker.onmessageerror = (event) => {
                reject(event);
            };
            const msg = {
                rnd: w,
                iterations: iterations,
                id: 0
            };
            worker.postMessage(msg);
        });
    }
}
function _isProbablyPrime(w, iterations) {
    /*
    PREFILTERING. Even values but 2 are not primes, so don't test.
    1 is not a prime and the M-R algorithm needs w>1.
    */
    if (w === 2n)
        return true;
    else if ((w & 1n) === 0n || w === 1n)
        return false;
    /*
      Test if any of the first 250 small primes are a factor of w. 2 is not tested because it was already tested above.
      */
    const firstPrimes = [
        3n,
        5n,
        7n,
        11n,
        13n,
        17n,
        19n,
        23n,
        29n,
        31n,
        37n,
        41n,
        43n,
        47n,
        53n,
        59n,
        61n,
        67n,
        71n,
        73n,
        79n,
        83n,
        89n,
        97n,
        101n,
        103n,
        107n,
        109n,
        113n,
        127n,
        131n,
        137n,
        139n,
        149n,
        151n,
        157n,
        163n,
        167n,
        173n,
        179n,
        181n,
        191n,
        193n,
        197n,
        199n,
        211n,
        223n,
        227n,
        229n,
        233n,
        239n,
        241n,
        251n,
        257n,
        263n,
        269n,
        271n,
        277n,
        281n,
        283n,
        293n,
        307n,
        311n,
        313n,
        317n,
        331n,
        337n,
        347n,
        349n,
        353n,
        359n,
        367n,
        373n,
        379n,
        383n,
        389n,
        397n,
        401n,
        409n,
        419n,
        421n,
        431n,
        433n,
        439n,
        443n,
        449n,
        457n,
        461n,
        463n,
        467n,
        479n,
        487n,
        491n,
        499n,
        503n,
        509n,
        521n,
        523n,
        541n,
        547n,
        557n,
        563n,
        569n,
        571n,
        577n,
        587n,
        593n,
        599n,
        601n,
        607n,
        613n,
        617n,
        619n,
        631n,
        641n,
        643n,
        647n,
        653n,
        659n,
        661n,
        673n,
        677n,
        683n,
        691n,
        701n,
        709n,
        719n,
        727n,
        733n,
        739n,
        743n,
        751n,
        757n,
        761n,
        769n,
        773n,
        787n,
        797n,
        809n,
        811n,
        821n,
        823n,
        827n,
        829n,
        839n,
        853n,
        857n,
        859n,
        863n,
        877n,
        881n,
        883n,
        887n,
        907n,
        911n,
        919n,
        929n,
        937n,
        941n,
        947n,
        953n,
        967n,
        971n,
        977n,
        983n,
        991n,
        997n,
        1009n,
        1013n,
        1019n,
        1021n,
        1031n,
        1033n,
        1039n,
        1049n,
        1051n,
        1061n,
        1063n,
        1069n,
        1087n,
        1091n,
        1093n,
        1097n,
        1103n,
        1109n,
        1117n,
        1123n,
        1129n,
        1151n,
        1153n,
        1163n,
        1171n,
        1181n,
        1187n,
        1193n,
        1201n,
        1213n,
        1217n,
        1223n,
        1229n,
        1231n,
        1237n,
        1249n,
        1259n,
        1277n,
        1279n,
        1283n,
        1289n,
        1291n,
        1297n,
        1301n,
        1303n,
        1307n,
        1319n,
        1321n,
        1327n,
        1361n,
        1367n,
        1373n,
        1381n,
        1399n,
        1409n,
        1423n,
        1427n,
        1429n,
        1433n,
        1439n,
        1447n,
        1451n,
        1453n,
        1459n,
        1471n,
        1481n,
        1483n,
        1487n,
        1489n,
        1493n,
        1499n,
        1511n,
        1523n,
        1531n,
        1543n,
        1549n,
        1553n,
        1559n,
        1567n,
        1571n,
        1579n,
        1583n,
        1597n
    ];
    for (let i = 0; i < firstPrimes.length && (firstPrimes[i] <= w); i++) {
        const p = firstPrimes[i];
        if (w === p)
            return true;
        else if (w % p === 0n)
            return false;
    }
    /*
      1. Let a be the largest integer such that 2**a divides w−1.
      2. m = (w−1) / 2**a.
      3. wlen = len (w).
      4. For i = 1 to iterations do
          4.1 Obtain a string b of wlen bits from an RBG.
          Comment: Ensure that 1 < b < w−1.
          4.2 If ((b ≤ 1) or (b ≥ w−1)), then go to step 4.1.
          4.3 z = b**m mod w.
          4.4 If ((z = 1) or (z = w − 1)), then go to step 4.7.
          4.5 For j = 1 to a − 1 do.
          4.5.1 z = z**2 mod w.
          4.5.2 If (z = w−1), then go to step 4.7.
          4.5.3 If (z = 1), then go to step 4.6.
          4.6 Return COMPOSITE.
          4.7 Continue.
          Comment: Increment i for the do-loop in step 4.
      5. Return PROBABLY PRIME.
      */
    let a = 0n;
    const d = w - 1n;
    let aux = d;
    while (aux % 2n === 0n) {
        aux /= 2n;
        ++a;
    }
    const m = d / (2n ** a);
    do {
        const b = randBetween(d, 2n);
        let z = modPow(b, m, w);
        if (z === 1n || z === d)
            continue;
        let j = 1;
        while (j < a) {
            z = modPow(z, 2n, w);
            if (z === d)
                break;
            if (z === 1n)
                return false;
            j++;
        }
        if (z !== d)
            return false;
    } while (--iterations !== 0);
    return true;
}
function _isProbablyPrimeWorkerUrl() {
    // Let's us first add all the required functions
    let workerCode = `'use strict';const ${eGcd.name}=${eGcd.toString()};const ${modInv.name}=${modInv.toString()};const ${modPow.name}=${modPow.toString()};const ${toZn.name}=${toZn.toString()};const ${randBitsSync.name}=${randBitsSync.toString()};const ${randBytesSync.name}=${randBytesSync.toString()};const ${randBetween.name}=${randBetween.toString()};const ${isProbablyPrime.name}=${_isProbablyPrime.toString()};${bitLength.toString()};${fromBuffer.toString()};`;
    workerCode += `onmessage=async function(e){const m={isPrime:await ${isProbablyPrime.name}(e.data.rnd,e.data.iterations),value:e.data.rnd,id:e.data.id};postMessage(m);}`;
    return _workerUrl(workerCode);
}

/**
 * A probably-prime (Miller-Rabin), cryptographically-secure, random-number generator.
 * The browser version uses web workers to parallelise prime look up. Therefore, it does not lock the UI
 * main process, and it can be much faster (if several cores or cpu are available).
 * The node version can also use worker_threads if they are available (enabled by default with Node 11 and
 * and can be enabled at runtime executing node --experimental-worker with node >=10.5.0).
 *
 * @param bitLength - The required bit length for the generated prime
 * @param iterations - The number of iterations for the Miller-Rabin Probabilistic Primality Test
 *
 * @throws {RangeError}
 * bitLength MUST be > 0
 *
 * @returns A promise that resolves to a bigint probable prime of bitLength bits.
 */
function prime(bitLength, iterations = 16) {
    if (bitLength < 1)
        throw new RangeError('bitLength MUST be > 0');
    /* istanbul ignore if */
    if (!_useWorkers) { // If there is no support for workers
        let rnd = 0n;
        do {
            rnd = fromBuffer(randBitsSync(bitLength, true));
        } while (!_isProbablyPrime(rnd, iterations));
        return new Promise((resolve) => { resolve(rnd); });
    }
    return new Promise((resolve, reject) => {
        const workerList = [];
        const _onmessage = (msg, newWorker) => {
            if (msg.isPrime) {
                // if a prime number has been found, stop all the workers, and return it
                for (let j = 0; j < workerList.length; j++) {
                    workerList[j].terminate();
                }
                while (workerList.length > 0) {
                    workerList.pop();
                }
                resolve(msg.value);
            }
            else { // if a composite is found, make the worker test another random number
                const buf = randBitsSync(bitLength, true);
                const rnd = fromBuffer(buf);
                try {
                    const msgToWorker = {
                        rnd: rnd,
                        iterations: iterations,
                        id: msg.id
                    };
                    newWorker.postMessage(msgToWorker);
                }
                catch (error) {
                    // The worker has already terminated. There is nothing to handle here
                }
            }
        };
        { // browser
            const workerURL = _isProbablyPrimeWorkerUrl();
            for (let i = 0; i < self.navigator.hardwareConcurrency - 1; i++) {
                const newWorker = new Worker(workerURL);
                newWorker.onmessage = (event) => _onmessage(event.data, newWorker);
                workerList.push(newWorker);
            }
        }
        for (let i = 0; i < workerList.length; i++) {
            randBits(bitLength, true).then(function (buf) {
                const rnd = fromBuffer(buf);
                workerList[i].postMessage({
                    rnd: rnd,
                    iterations: iterations,
                    id: i
                });
            }).catch(reject);
        }
    });
}
/**
 * A probably-prime (Miller-Rabin), cryptographically-secure, random-number generator.
 * The sync version is NOT RECOMMENDED since it won't use workers and thus it'll be slower and may freeze thw window in browser's javascript. Please consider using prime() instead.
 *
 * @param bitLength - The required bit length for the generated prime
 * @param iterations - The number of iterations for the Miller-Rabin Probabilistic Primality Test
 *
 * @throws {RangeError}
 * bitLength MUST be > 0
 *
 * @returns A bigint probable prime of bitLength bits.
 */
function primeSync(bitLength, iterations = 16) {
    if (bitLength < 1)
        throw new RangeError('bitLength MUST be > 0');
    let rnd = 0n;
    do {
        rnd = fromBuffer(randBitsSync(bitLength, true));
    } while (!_isProbablyPrime(rnd, iterations));
    return rnd;
}

export { abs, bitLength, eGcd, gcd, isProbablyPrime, lcm, max, min, modInv, modPow, prime, primeSync, randBetween, randBits, randBitsSync, randBytes, randBytesSync, toZn };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.browser.js","sources":["../../node_modules/bigint-mod-arith/dist/esm/index.browser.js","../../src/ts/fromBuffer.ts","../../src/ts/randBytes.ts","../../src/ts/randBits.ts","../../src/ts/randBetween.ts","../../src/ts/workerUtils.ts","../../src/ts/isProbablyPrime.ts","../../src/ts/prime.ts"],"sourcesContent":null,"names":[],"mappings":"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G;QACH,GAAG;QACH,GAAG;QACH,GAAG;QACH,GAAG;QACH,GAAG;QACH,GAAG;QACH,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAA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"}