/**
 * 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 (minimum) length of a number expressed in bits.
 *
 * @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 {@link RangeError} if a or b are <= 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) as bigint / gcd(a, b)
    return abs((a / gcd(a, b)) * 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 {@link RangeError} if n <= 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 {@link RangeError} if 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 {@link RangeError} if n <= 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 - Set to true if you want to force the output to have a bit length of 8*byteLength. It basically forces the msb to be 1
 *
 * @throws {@link RangeError} if byteLength < 1
 *
 * @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()
 * This is the synchronous version, consider using the asynchronous one for improved efficiency.
 *
 * @param byteLength - The desired number of random bytes
 * @param forceLength - Set to true if you want to force the output to have a bit length of 8*byteLength. It basically forces the msb to be 1
 *
 * @throws {@link RangeError} if byteLength < 1
 *
 * @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 - Set to true if you want to force the output to have a specific bit length. It basically forces the msb to be 1
 *
 * @throws {@link RangeError} if bitLength < 1
 *
 * @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 - Set to true if you want to force the output to have a specific bit length. It basically forces the msb to be 1
 *
 * @throws {@link RangeError} if bitLength < 1
 *
 * @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].
 * @param max Returned value will be <= max
 * @param min Returned value will be >= min
 *
 * @throws {@link RangeError} if max <= min
 *
 * @returns A cryptographically secure random bigint between [min,max]
 */
function randBetween(max, min = 1n) {
    if (max <= min)
        throw new RangeError('Arguments MUST be: 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 of FIPS 186-4
 * @param disableWorkers - Disable the use of workers for the primality test
 *
 * @throws {@link RangeError} if w<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) => {
                if (event?.data?._bcu?.isPrime !== undefined) {
                    worker.terminate();
                    resolve(event.data._bcu.isPrime);
                }
            };
            worker.onmessageerror = (event) => {
                reject(event);
            };
            const msg = {
                _bcu: {
                    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(msg) {
    if (msg !== undefined && msg.data !== undefined && msg.data._bcu !== undefined && msg.data._bcu.id !== undefined && msg.data._bcu.iterations !== undefined && msg.data._bcu.rnd !== undefined) {
      const msgToParent = {
        _bcu: {
          isPrime: await ${isProbablyPrime.name}(msg.data._bcu.rnd, msg.data._bcu.iterations),
          value: msg.data._bcu.rnd,
          id: msg.data._bcu.id
        }
      };
      postMessage(msgToParent);
    }
  }`;
    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 {@link RangeError} if bitLength < 1
 *
 * @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');
    /* c8 ignore start */
    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); });
    }
    /* c8 ignore stop */
    return new Promise((resolve, reject) => {
        const workerList = [];
        const _onmessage = (msg, newWorker) => {
            if (msg._bcu.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(); // eslint-disable-line @typescript-eslint/no-floating-promises
                }
                while (workerList.length > 0) {
                    workerList.pop();
                }
                resolve(msg._bcu.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 = {
                        _bcu: {
                            rnd: rnd,
                            iterations: iterations,
                            id: msg._bcu.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({
                    _bcu: {
                        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 {@link RangeError} if bitLength < 1
 *
 * @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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J,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,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;KACN,CAAA;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,KAAK,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;AACpE,QAAA,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;QACxB,IAAI,CAAC,KAAK,CAAC;AAAE,YAAA,OAAO,IAAI,CAAA;AACnB,aAAA,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE;AAAE,YAAA,OAAO,KAAK,CAAA;AACpC,KAAA;AAED;;;;;;;;;;;;;;;;;;AAkBI;IACJ,IAAI,CAAC,GAAG,EAAE,CAAA;AACV,IAAA,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAA;IAChB,IAAI,GAAG,GAAG,CAAC,CAAA;AACX,IAAA,OAAO,GAAG,GAAG,EAAE,KAAK,EAAE,EAAE;QACtB,GAAG,IAAI,EAAE,CAAA;AACT,QAAA,EAAE,CAAC,CAAA;AACJ,KAAA;IAED,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;IAEvB,GAAG;QACD,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;QAC5B,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;AACvB,QAAA,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC;YAAE,SAAQ;QACjC,IAAI,CAAC,GAAG,CAAC,CAAA;QACT,OAAO,CAAC,GAAG,CAAC,EAAE;YACZ,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;YACpB,IAAI,CAAC,KAAK,CAAC;gBAAE,MAAK;YAClB,IAAI,CAAC,KAAK,EAAE;AAAE,gBAAA,OAAO,KAAK,CAAA;AAC1B,YAAA,CAAC,EAAE,CAAA;AACJ,SAAA;QACD,IAAI,CAAC,KAAK,CAAC;AAAE,YAAA,OAAO,KAAK,CAAA;AAC1B,KAAA,QAAQ,EAAE,UAAU,KAAK,CAAC,EAAC;AAE5B,IAAA,OAAO,IAAI,CAAA;AACb,CAAC;SAEe,yBAAyB,GAAA;;AAEvC,IAAA,IAAI,UAAU,GAAG,CAAA;;AAET,QAAA,EAAA,IAAI,CAAC,IAAI,CAAA,GAAA,EAAM,IAAI,CAAC,QAAQ,EAAE,CAAA;AAC9B,QAAA,EAAA,MAAM,CAAC,IAAI,CAAA,GAAA,EAAM,MAAM,CAAC,QAAQ,EAAE,CAAA;AAClC,QAAA,EAAA,MAAM,CAAC,IAAI,CAAA,GAAA,EAAM,MAAM,CAAC,QAAQ,EAAE,CAAA;AAClC,QAAA,EAAA,IAAI,CAAC,IAAI,CAAA,GAAA,EAAM,IAAI,CAAC,QAAQ,EAAE,CAAA;AAC9B,QAAA,EAAA,YAAY,CAAC,IAAI,CAAA,GAAA,EAAM,YAAY,CAAC,QAAQ,EAAE,CAAA;AAC9C,QAAA,EAAA,aAAa,CAAC,IAAI,CAAA,GAAA,EAAM,aAAa,CAAC,QAAQ,EAAE,CAAA;AAChD,QAAA,EAAA,WAAW,CAAC,IAAI,CAAA,GAAA,EAAM,WAAW,CAAC,QAAQ,EAAE,CAAA;AAC5C,QAAA,EAAA,eAAe,CAAC,IAAI,CAAA,GAAA,EAAM,gBAAgB,CAAC,QAAQ,EAAE,CAAA;IAC3D,SAAS,CAAC,QAAQ,EAAE,CAAA;AACpB,EAAA,EAAA,UAAU,CAAC,QAAQ,EAAE,CAAA,CAAA,CAAG,CAAA;AAE1B,IAAA,UAAU,IAAI,CAAA;;;;;AAKW,yBAAA,EAAA,eAAe,CAAC,IAAI,CAAA;;;;;;;IAO3C,CAAA;AAEF,IAAA,OAAO,UAAU,CAAC,UAAU,CAAC,CAAA;AAC/B;;AC7ZA;;;;;;;;;;;;;AAaG;SACa,KAAK,CAAE,SAAiB,EAAE,aAAqB,EAAE,EAAA;IAC/D,IAAI,SAAS,GAAG,CAAC;AAAE,QAAA,MAAM,IAAI,UAAU,CAAC,uBAAuB,CAAC,CAAA;;AAGhE,IAAA,IAAI,CAAC,WAAW,EAAE;QAChB,IAAI,GAAG,GAAG,EAAE,CAAA;QACZ,GAAG;YACD,GAAG,GAAG,UAAU,CAAC,YAAY,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAA;AAChD,SAAA,QAAQ,CAAC,gBAAgB,CAAC,GAAG,EAAE,UAAU,CAAC,EAAC;AAC5C,QAAA,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,KAAI,EAAG,OAAO,CAAC,GAAG,CAAC,CAAA,EAAE,CAAC,CAAA;AAClD,KAAA;;IAED,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,KAAI;QACrC,MAAM,UAAU,GAA+B,EAAE,CAAA;AACjD,QAAA,MAAM,UAAU,GAAG,CAAC,GAAoB,EAAE,SAA8B,KAAU;AAChF,YAAA,IAAI,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE;;AAEpB,gBAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBAC1C,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,CAAA;AAC1B,iBAAA;AACD,gBAAA,OAAO,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE;oBAC5B,UAAU,CAAC,GAAG,EAAE,CAAA;AACjB,iBAAA;AACD,gBAAA,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AACxB,aAAA;AAAM,iBAAA;gBACL,MAAM,GAAG,GAAG,YAAY,CAAC,SAAS,EAAE,IAAI,CAAC,CAAA;AACzC,gBAAA,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC,CAAA;gBAC3B,IAAI;AACF,oBAAA,MAAM,WAAW,GAAoB;AACnC,wBAAA,IAAI,EAAE;AACJ,4BAAA,GAAG,EAAE,GAAG;AACR,4BAAA,UAAU,EAAE,UAAU;AACtB,4BAAA,EAAE,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE;AAChB,yBAAA;qBACF,CAAA;AACD,oBAAA,SAAS,CAAC,WAAW,CAAC,WAAW,CAAC,CAAA;AACnC,iBAAA;AAAC,gBAAA,OAAO,KAAK,EAAE;;AAEf,iBAAA;AACF,aAAA;AACH,SAAC,CAAA;QACe;AACd,YAAA,MAAM,SAAS,GAAG,yBAAyB,EAAE,CAAA;AAC7C,YAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,mBAAmB,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;AAC/D,gBAAA,MAAM,SAAS,GAAG,IAAI,MAAM,CAAC,SAAS,CAAC,CAAA;AACvC,gBAAA,SAAS,CAAC,SAAS,GAAG,CAAC,KAAK,KAAK,UAAU,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;AAClE,gBAAA,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;AAC3B,aAAA;AACF,SAMA;AACD,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC1C,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,UAAU,GAAsB,EAAA;AAC7D,gBAAA,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC,CAAA;AAC3B,gBAAA,UAAU,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;AACxB,oBAAA,IAAI,EAAE;AACJ,wBAAA,GAAG,EAAE,GAAG;AACR,wBAAA,UAAU,EAAE,UAAU;AACtB,wBAAA,EAAE,EAAE,CAAC;AACN,qBAAA;AACF,iBAAA,CAAC,CAAA;AACJ,aAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;AACjB,SAAA;AACH,KAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;;;;AAUG;SACa,SAAS,CAAE,SAAiB,EAAE,aAAqB,EAAE,EAAA;IACnE,IAAI,SAAS,GAAG,CAAC;AAAE,QAAA,MAAM,IAAI,UAAU,CAAC,uBAAuB,CAAC,CAAA;IAChE,IAAI,GAAG,GAAG,EAAE,CAAA;IACZ,GAAG;QACD,GAAG,GAAG,UAAU,CAAC,YAAY,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAA;AAChD,KAAA,QAAQ,CAAC,gBAAgB,CAAC,GAAG,EAAE,UAAU,CAAC,EAAC;AAC5C,IAAA,OAAO,GAAG,CAAA;AACZ;;;;"}