// Module ID: 8926
// Function ID: 70259
// Name: XorAndSalsa
// Dependencies: [5, 8927, 8928, 8930, 8932]
// Exports: scrypt, scryptAsync

// Module 8926 (XorAndSalsa)
import asyncGeneratorStep from "asyncGeneratorStep";

function XorAndSalsa(B32, sum, V, sum2, B32, sum1) {
  let tmp81;
  let tmp82;
  let tmp83;
  let tmp84;
  let tmp85;
  let tmp86;
  let tmp87;
  let tmp88;
  let tmp89;
  let tmp90;
  let tmp91;
  let tmp92;
  let tmp93;
  let tmp94;
  let tmp95;
  let tmp96;
  let tmp = +sum;
  const tmp6 = B32[+tmp + 1] ^ V[++sum2 + 1];
  const tmp8 = +++sum2 + 1 + 1;
  const tmp9 = B32[++tmp + 1 + 1] ^ V[tmp8];
  const tmp10 = +++tmp + 1 + 1 + 1;
  const tmp15 = B32[+tmp10 + 1] ^ V[++tmp8 + 1 + 1];
  const tmp17 = +++tmp8 + 1 + 1 + 1;
  const tmp18 = B32[++tmp10 + 1 + 1] ^ V[tmp17];
  const tmp19 = +++tmp10 + 1 + 1 + 1;
  const tmp24 = B32[+tmp19 + 1] ^ V[++tmp17 + 1 + 1];
  const tmp26 = +++tmp17 + 1 + 1 + 1;
  const tmp27 = B32[++tmp19 + 1 + 1] ^ V[tmp26];
  const tmp28 = +++tmp19 + 1 + 1 + 1;
  const tmp33 = B32[+tmp28 + 1] ^ V[++tmp26 + 1 + 1];
  const tmp35 = +++tmp26 + 1 + 1 + 1;
  const tmp36 = B32[++tmp28 + 1 + 1] ^ V[tmp35];
  const tmp37 = +++tmp28 + 1 + 1 + 1;
  const tmp42 = B32[+tmp37 + 1] ^ V[++tmp35 + 1 + 1];
  const tmp44 = +++tmp35 + 1 + 1 + 1;
  const tmp45 = B32[++tmp37 + 1 + 1] ^ V[tmp44];
  const tmp46 = B32[+++tmp37 + 1 + 1 + 1] ^ V[+tmp44 + 1];
  let tmp47 = tmp3;
  let tmp48 = tmp6;
  let tmp49 = tmp9;
  let tmp50 = tmp12;
  let tmp51 = tmp15;
  let tmp52 = tmp18;
  let tmp53 = tmp21;
  let tmp54 = tmp24;
  let tmp55 = tmp27;
  let tmp56 = tmp30;
  let tmp57 = tmp33;
  let tmp58 = tmp36;
  let tmp59 = tmp39;
  let tmp60 = tmp42;
  let tmp61 = tmp45;
  let tmp62 = tmp46;
  let num = 0;
  do {
    let tmp63 = require;
    let tmp64 = dependencyMap;
    let tmp65 = tmp51 ^ require(8927) /* asciiToBase16 */.rotl(tmp47 + tmp59 | 0, 7);
    let tmp66 = tmp55 ^ require(8927) /* asciiToBase16 */.rotl(tmp65 + tmp47 | 0, 9);
    let tmp67 = tmp59 ^ require(8927) /* asciiToBase16 */.rotl(tmp66 + tmp65 | 0, 13);
    let tmp68 = tmp47 ^ require(8927) /* asciiToBase16 */.rotl(tmp67 + tmp66 | 0, 18);
    let tmp69 = tmp56 ^ require(8927) /* asciiToBase16 */.rotl(tmp52 + tmp48 | 0, 7);
    let tmp70 = tmp60 ^ require(8927) /* asciiToBase16 */.rotl(tmp69 + tmp52 | 0, 9);
    let tmp71 = tmp48 ^ require(8927) /* asciiToBase16 */.rotl(tmp70 + tmp69 | 0, 13);
    let tmp72 = tmp52 ^ require(8927) /* asciiToBase16 */.rotl(tmp71 + tmp70 | 0, 18);
    let tmp73 = tmp61 ^ require(8927) /* asciiToBase16 */.rotl(tmp57 + tmp53 | 0, 7);
    let tmp74 = tmp49 ^ require(8927) /* asciiToBase16 */.rotl(tmp73 + tmp57 | 0, 9);
    let tmp75 = tmp53 ^ require(8927) /* asciiToBase16 */.rotl(tmp74 + tmp73 | 0, 13);
    let tmp76 = tmp57 ^ require(8927) /* asciiToBase16 */.rotl(tmp75 + tmp74 | 0, 18);
    let tmp77 = tmp50 ^ require(8927) /* asciiToBase16 */.rotl(tmp62 + tmp58 | 0, 7);
    let tmp78 = tmp54 ^ require(8927) /* asciiToBase16 */.rotl(tmp77 + tmp62 | 0, 9);
    let tmp79 = tmp58 ^ require(8927) /* asciiToBase16 */.rotl(tmp78 + tmp77 | 0, 13);
    let tmp80 = tmp62 ^ require(8927) /* asciiToBase16 */.rotl(tmp79 + tmp78 | 0, 18);
    tmp81 = tmp71 ^ require(8927) /* asciiToBase16 */.rotl(tmp68 + tmp77 | 0, 7);
    tmp82 = tmp74 ^ require(8927) /* asciiToBase16 */.rotl(tmp81 + tmp68 | 0, 9);
    tmp83 = tmp77 ^ require(8927) /* asciiToBase16 */.rotl(tmp82 + tmp81 | 0, 13);
    tmp84 = tmp68 ^ require(8927) /* asciiToBase16 */.rotl(tmp83 + tmp82 | 0, 18);
    tmp85 = tmp75 ^ require(8927) /* asciiToBase16 */.rotl(tmp72 + tmp65 | 0, 7);
    tmp86 = tmp78 ^ require(8927) /* asciiToBase16 */.rotl(tmp85 + tmp72 | 0, 9);
    tmp87 = tmp65 ^ require(8927) /* asciiToBase16 */.rotl(tmp86 + tmp85 | 0, 13);
    tmp88 = tmp72 ^ require(8927) /* asciiToBase16 */.rotl(tmp87 + tmp86 | 0, 18);
    tmp89 = tmp79 ^ require(8927) /* asciiToBase16 */.rotl(tmp76 + tmp69 | 0, 7);
    tmp90 = tmp66 ^ require(8927) /* asciiToBase16 */.rotl(tmp89 + tmp76 | 0, 9);
    tmp91 = tmp69 ^ require(8927) /* asciiToBase16 */.rotl(tmp90 + tmp89 | 0, 13);
    tmp92 = tmp76 ^ require(8927) /* asciiToBase16 */.rotl(tmp91 + tmp90 | 0, 18);
    tmp93 = tmp67 ^ require(8927) /* asciiToBase16 */.rotl(tmp80 + tmp73 | 0, 7);
    tmp94 = tmp70 ^ require(8927) /* asciiToBase16 */.rotl(tmp93 + tmp80 | 0, 9);
    tmp95 = tmp73 ^ require(8927) /* asciiToBase16 */.rotl(tmp94 + tmp93 | 0, 13);
    tmp96 = tmp80 ^ require(8927) /* asciiToBase16 */.rotl(tmp95 + tmp94 | 0, 18);
    num = num + 2;
    tmp47 = tmp84;
    tmp48 = tmp81;
    tmp49 = tmp82;
    tmp50 = tmp83;
    tmp51 = tmp87;
    tmp52 = tmp88;
    tmp53 = tmp85;
    tmp54 = tmp86;
    tmp55 = tmp90;
    tmp56 = tmp91;
    tmp57 = tmp92;
    tmp58 = tmp89;
    tmp59 = tmp93;
    tmp60 = tmp94;
    tmp61 = tmp95;
    tmp62 = tmp96;
  } while (num < 8);
  B32[+sum1] = (B32[tmp] ^ V[+sum2]) + tmp84 | 0;
  B32[++sum1 + 1] = tmp6 + tmp81 | 0;
  const tmp99 = +++sum1 + 1 + 1;
  B32[tmp99] = tmp9 + tmp82 | 0;
  tmp = +tmp99 + 1;
  B32[tmp] = (B32[tmp10] ^ V[+tmp8 + 1]) + tmp83 | 0;
  tmp = +tmp + 1;
  B32[tmp] = tmp15 + tmp87 | 0;
  tmp = +tmp + 1;
  B32[tmp] = tmp18 + tmp88 | 0;
  tmp = +tmp + 1;
  B32[tmp] = (B32[tmp19] ^ V[+tmp17 + 1]) + tmp85 | 0;
  tmp = +tmp + 1;
  B32[tmp] = tmp24 + tmp86 | 0;
  tmp = +tmp + 1;
  B32[tmp] = tmp27 + tmp90 | 0;
  tmp = +tmp + 1;
  B32[tmp] = (B32[tmp28] ^ V[+tmp26 + 1]) + tmp91 | 0;
  tmp = +tmp + 1;
  B32[tmp] = tmp33 + tmp92 | 0;
  tmp = +tmp + 1;
  B32[tmp] = tmp36 + tmp89 | 0;
  tmp = +tmp + 1;
  B32[tmp] = (B32[tmp37] ^ V[+tmp35 + 1]) + tmp93 | 0;
  tmp = +tmp + 1;
  B32[tmp] = tmp42 + tmp94 | 0;
  tmp = +tmp + 1;
  B32[tmp] = tmp45 + tmp95 | 0;
  B32[+tmp + 1] = tmp46 + tmp96 | 0;
}
function BlockMix(V, sum2, B32, result, arg4) {
  let sum4 = sum2;
  let sum3 = result;
  let sum = result + 16 * arg4;
  let num = 0;
  do {
    B32[sum + num] = V[sum4 + 16 * (2 * arg4 - 1) + num];
    num = num + 1;
  } while (num < 16);
  let num2 = 0;
  if (0 < arg4) {
    do {
      let tmp4 = XorAndSalsa;
      let tmp5 = B32;
      let tmp6 = sum;
      let tmp7 = V;
      let tmp8 = sum4;
      let tmp9 = B32;
      let tmp10 = sum3;
      let tmp11 = XorAndSalsa(B32, sum, V, sum4, B32, sum3);
      let tmp12 = sum4;
      let tmp14 = sum;
      let sum1 = sum;
      let tmp13 = sum3;
      if (num2 > 0) {
        sum1 = sum + 16;
      }
      let tmp16 = XorAndSalsa;
      sum2 = sum4 + 16;
      let tmp18 = B32;
      let tmp19 = sum3;
      let tmp20 = V;
      let tmp21 = sum2;
      let tmp22 = B32;
      let tmp23 = sum1;
      let tmp24 = XorAndSalsa(B32, tmp13, V, sum2, B32, sum1);
      num2 = num2 + 1;
      sum3 = sum3 + 16;
      sum4 = sum2 + 16;
      sum = sum1;
    } while (num2 < arg4);
  }
}
function scryptInit(B, B, arg2) {
  let N;
  let asyncTick;
  let dkLen;
  let maxmem;
  let onProgress;
  let p;
  let r;
  ({ N, r, p, dkLen, asyncTick, maxmem, onProgress } = onProgress(result2[1]).checkOpts({ dkLen: 32, asyncTick: 10, maxmem: 1073742848 }, arg2));
  onProgress(result2[2]).number(N);
  onProgress(result2[2]).number(r);
  onProgress(result2[2]).number(p);
  onProgress(result2[2]).number(dkLen);
  onProgress(result2[2]).number(asyncTick);
  onProgress(result2[2]).number(maxmem);
  if (undefined !== onProgress) {
    if ("function" !== typeof onProgress) {
      const _Error4 = Error;
      const error = new Error("progressCb should be function");
      throw error;
    }
  }
  let result = 128 * r;
  if (N > 1) {
    if (!(N & N - 1)) {
      if (N <= 4294967296) {
        if (p >= 0) {
          if (p <= 137438953440 / result) {
            if (dkLen >= 0) {
              if (dkLen <= 137438953440) {
                const result1 = result * (N + p);
                if (result1 > maxmem) {
                  const _Error = Error;
                  const _HermesInternal = HermesInternal;
                  const error1 = new Error("Scrypt: parameters too large, " + result1 + " (128 * r * (N + p)) > " + maxmem + " (maxmem)");
                  throw error1;
                } else {
                  let obj = { c: 1, dkLen: result * p };
                  const pbkdf2Result = onProgress(result2[3]).pbkdf2(onProgress(result2[4]).sha256, B, B, obj);
                  const _Uint8Array = Uint8Array;
                  const uint8Array = new Uint8Array(result * N);
                  const u32Result = onProgress(result2[1]).u32(pbkdf2Result);
                  const _Uint8Array2 = Uint8Array;
                  const uint8Array1 = new Uint8Array(result);
                  function blockMixCb() {

                  }
                  const u32Result1 = onProgress(result2[1]).u32(uint8Array);
                  if (onProgress) {
                    result2 = 2 * N * p;
                    const _Math = Math;
                    const _Math2 = Math;
                    let closure_2 = Math.max(Math.floor(result2 / 10000), 1);
                    let c3 = 0;
                    blockMixCb = function blockMixCb() {
                      closure_3 = closure_3 + 1;
                      let tmp = !onProgress;
                      if (!tmp) {
                        let result = closure_3 % closure_2;
                        if (result) {
                          result = closure_3 !== result2;
                        }
                        tmp = result;
                      }
                      if (!tmp) {
                        onProgress(closure_3 / result2);
                      }
                    };
                  }
                  obj = { N, r, p, dkLen, blockSize32: result / 4, V: u32Result1, B32: u32Result, B: pbkdf2Result, tmp: onProgress(result2[1]).u32(uint8Array1), blockMixCb, asyncTick };
                  return obj;
                }
              }
            }
            const _Error2 = Error;
            const error2 = new Error("Scrypt: dkLen should be positive integer less than or equal to (2^32 - 1) * 32");
            throw error2;
          }
        }
        const _Error3 = Error;
        const error3 = new Error("Scrypt: p must be a positive integer less than or equal to ((2^32 - 1) * 32) / (128 * r)");
        throw error3;
      }
    }
  }
  const error4 = new Error("Scrypt: N must be larger than 1, a power of 2, and less than 2^32");
  throw error4;
}
function scryptOutput(B, dkLen, B, V, arr3) {
  B.fill(0);
  V.fill(0);
  arr3.fill(0);
  return require(8930) /* pbkdf2Init */.pbkdf2(require(8932) /* _callSuper */.sha256, B, B, { c: 1, dkLen });
}
function _scryptAsync() {
  // CreateGeneratorClosureLongIndex (0x67)
  const obj = asyncGeneratorStep(tmp);
  return obj(...arguments);
}

export const scrypt = function scrypt(B, B) {
  let B32;
  let N;
  let V;
  let blockMixCb;
  let blockSize32;
  let dkLen;
  let p;
  let r;
  let tmp2;
  ({ N, r, p, dkLen, blockSize32, V, B32, B, tmp: tmp2, blockMixCb } = scryptInit(B, B, arg2));
  if (!require(8927) /* asciiToBase16 */.isLE) {
    require(8927) /* asciiToBase16 */.byteSwap32(B32);
  }
  for (let num = 0; num < p; num = num + 1) {
    let result = blockSize32 * num;
    for (let num2 = 0; num2 < blockSize32; num2 = num2 + 1) {
      V[num2] = B32[result + num2];
    }
    let num3 = 0;
    let num4 = 0;
    if (0 < N - 1) {
      do {
        let tmp7 = BlockMix;
        let sum = num4 + blockSize32;
        let tmp9 = V;
        let tmp10 = num4;
        let tmp11 = V;
        let tmp12 = sum;
        let tmp13 = r;
        let tmp14 = BlockMix(V, num4, V, sum, r);
        let blockMixCbResult = blockMixCb();
        num3 = num3 + 1;
        num4 = sum;
        diff = N - 1;
      } while (num3 < diff);
    }
    let tmp17 = BlockMix;
    let tmp18 = V;
    let tmp19 = B32;
    let tmp20 = result;
    let tmp21 = r;
    let tmp22 = BlockMix(V, (N - 1) * blockSize32, B32, result, r);
    let blockMixCbResult1 = blockMixCb();
    let num5 = 0;
    if (0 < N) {
      do {
        let result1 = B32[result + blockSize32 - 16] % N;
        let num6 = 0;
        let num7 = 0;
        if (0 < blockSize32) {
          do {
            tmp2[num6] = B32[result + num6] ^ V[result1 * blockSize32 + num6];
            num6 = num6 + 1;
            num7 = num6;
          } while (num6 < blockSize32);
        }
        let tmp25 = BlockMix;
        let tmp26 = tmp2;
        let num8 = 0;
        let tmp27 = B32;
        let tmp28 = result;
        let tmp29 = r;
        let tmp30 = BlockMix(tmp2, 0, B32, result, r);
        let blockMixCbResult2 = blockMixCb();
        num5 = num5 + 1;
        let tmp32 = num7;
        let tmp33 = result1;
      } while (num5 < N);
    }
  }
  if (!require(8927) /* asciiToBase16 */.isLE) {
    require(8927) /* asciiToBase16 */.byteSwap32(B32);
  }
  return scryptOutput(B, dkLen, B, V, tmp2);
};
export const scryptAsync = function scryptAsync(uint8Array, arg1, arg2) {
  return _scryptAsync(...arguments);
};