| 1 | {"version":3,"sources":["webpack:///webpack/bootstrap cc045fd835481af0af86","webpack:///../~/@goodmind/node-cryptojs-aes/lib/core.js","webpack:///../~/pako/lib/utils/common.js","webpack:///./bin.js","webpack:///../~/@goodmind/node-cryptojs-aes/cryptojs.js","webpack:///../~/@goodmind/node-cryptojs-aes/lib/aes.js","webpack:///../~/@goodmind/node-cryptojs-aes/lib/cipher-core.js","webpack:///../~/@goodmind/node-cryptojs-aes/lib/enc-base64.js","webpack:///../~/@goodmind/node-cryptojs-aes/lib/evpkdf.js","webpack:///../~/@goodmind/node-cryptojs-aes/lib/jsonformatter.js","webpack:///../~/@goodmind/node-cryptojs-aes/lib/md5.js","webpack:///../~/@goodmind/node-cryptojs-aes/lib/sha256.js","webpack:///./leemon.js","webpack:///../~/jsbn/index.js","webpack:///../~/pako/lib/inflate.js","webpack:///../~/pako/lib/utils/strings.js","webpack:///../~/pako/lib/zlib/adler32.js","webpack:///../~/pako/lib/zlib/constants.js","webpack:///../~/pako/lib/zlib/crc32.js","webpack:///../~/pako/lib/zlib/gzheader.js","webpack:///../~/pako/lib/zlib/inffast.js","webpack:///../~/pako/lib/zlib/inflate.js","webpack:///../~/pako/lib/zlib/inftrees.js","webpack:///../~/pako/lib/zlib/messages.js","webpack:///../~/pako/lib/zlib/zstream.js","webpack:///../~/rusha/rusha.js","webpack:///../~/webpack/buildin/global.js","webpack:///./worker.js"],"names":["CryptoJS","rushaInstance","bigint","num","toString","bigStringInt","strNum","dHexDump","bytes","arr","i","length","push","console","log","join","bytesToHex","bytesFromHex","hexString","len","start","parseInt","charAt","substr","bytesToBase64","mod3","result","nLen","nUint24","nIdx","String","fromCharCode","uint6ToBase64","replace","nUint6","bytesCmp","bytes1","bytes2","bytesXor","bytesToWords","ArrayBuffer","Uint8Array","words","lib","WordArray","init","bytesFromWords","wordArray","sigBytes","bytesFromBigInt","bigInt","toByteArray","padding","needPadding","bufferConcat","concat","slice","bytesFromLeemonBigInt","str","bigInt2str","bytesToArrayBuffer","b","buffer","convertToArrayBuffer","undefined","byteLength","BYTES_PER_ELEMENT","convertToUint8Array","convertToByteArray","Array","isArray","newBytes","bytesFromArrayBuffer","byteView","from","buffer1","buffer2","l1","l2","tmp","set","longToInts","sLong","divRem","divideAndRemainder","intValue","longToBytes","reverse","longFromInts","high","low","shiftLeft","add","intToUint","val","uintToInt","sha1HashSync","hashBytes","rawDigest","sha1BytesSync","sha256HashSync","hashWords","SHA256","rsaEncrypt","publicKey","addPadding","N","modulus","E","exponent","X","encryptedBigInt","modPowInt","encryptedBytes","blockSize","zeroes","nextBytes","aesEncryptSync","keyBytes","ivBytes","encryptedWords","AES","encrypt","iv","pad","NoPadding","mode","IGE","ciphertext","aesDecryptSync","decryptedWords","decrypt","gzipUncompress","inflate","nextRandomInt","maxValue","Math","floor","random","pqPrimeFactorization","pqBytes","what","pqPrimeLeemon","str2bigInt","ceil","pqPrimeJsbn","it","g","q","x","y","clone","lim","j","a","c","equals","BigInteger","ZERO","and","ONE","compareTo","subtract","shiftRight","z","gcd","f","divide","P","Q","minBits","minLen","copyInt_","copy_","isZero","add_","greater","sub_","rightShift_","eGCD_","equalsInt","divide_","bytesModPow","m","xBigInt","yBigInt","mBigInt","resBigInt","powMod","e","error","modPow","bpe","mask","radix","digitsStr","one","int2bigInt","t","ss","s0","s1","s2","s3","s4","s5","s6","s7","T","sa","mr_x1","mr_r","mr_a","eg_v","eg_u","eg_A","eg_B","eg_C","eg_D","md_q1","md_q2","md_q3","md_r","md_r1","md_r2","md_tt","primes","pows","s_i","s_i2","s_R","s_rm","s_q","s_n1","s_a","s_r2","s_n","s_b","s_d","s_x1","s_x2","s_aa","rpprb","k","buff","findPrimes","n","s","p","ans","millerRabinInt","dup","millerRabin","addInt_","powMod_","squareMod_","bitSize","w","expand","randTruePrime","randTruePrime_","trim","randProbPrime","randProbPrimeRounds","divisible","B","randBigInt_","modInt","mod","mod_","addInt","mult","mult_","sub","inverseMod","inverseMod_","multMod","multMod_","pm","dd","r","zz","recSize","pow","recLimit","carry_","multInt_","GCD_","randBigInt","GCD","xc","yc","xp","yp","A","C","D","sing","qp","linComb_","max","halve_","negative","inverseModInt","inverseModInt_","v","leftShift_","greaterShift","shift","kx","ky","y1","y2","subShift_","linCombShift_","addShift_","bits","minSize","base","d","kk","indexOf","substring","divInt_","ys","kn","k1","k2","np","mont_","ui","ks","info","runTask","data","task","Error","onmessage","taskID","postMessage"],"mappings":";AAAA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA,mDAA2C,cAAc;;AAEzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAK;AACL;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;AAEA;AACA;;;;;;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,uBAAuB,OAAO;AAC9B;AACA,wBAAwB,OAAO;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,aAAa;;AAEb;AACA;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,aAAa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA,aAAa;;AAEb;AACA;AACA;AACA,uBAAuB,OAAO;AAC9B;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,aAAa;;AAEb;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA,kBAAkB,MAAM;AACxB,kBAAkB,OAAO;AACzB;AACA;AACA;AACA;AACA;AACA,mBAAmB,MAAM;AACzB,mBAAmB,OAAO;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,aAAa;AACb;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,QAAQ;AAC3B;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,UAAU;AAC7B;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,+BAA+B,kBAAkB;AACjD;AACA;AACA;AACA,aAAa;AACb;AACA,+BAA+B,kBAAkB;AACjD;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;;AAEA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,YAAY;AACvC;AACA;;AAEA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,UAAU;AAC7B;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,2BAA2B,cAAc;AACzC;AACA;AACA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,2BAA2B,kBAAkB;AAC7C;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,UAAU;AAC7B;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,2BAA2B,cAAc;AACzC;AACA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,2BAA2B,qBAAqB;AAChD;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,UAAU;AAC7B;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,iBAAiB;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA;AACA,mBAAmB,QAAQ;AAC3B;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,oCAAoC,sBAAsB;AAC1D;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS;;AAET;AACA,KAAK;;AAEL;AACA;AACA;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,iBAAiB;AACpC;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA,mBAAmB,iBAAiB;AACpC;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,SAAS;;AAET;;AAEA;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,SAAS;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,SAAS;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA,CAAC;;AAED;;;;;;;;ACzsBA;;;AAGA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA,kBAAkB,UAAU;;AAE5B;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA,4BAA4B,YAAY;AACxC,qBAAqB,8BAA8B;AACnD;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,SAAS;AAC5B;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA,kCAAkC,OAAO;AACzC;AAC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AACA;AACA;AACA,SAAS;;AAET;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,+BAA+B,iBAAiB;AAChD;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;;;;;ACtND;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,kBAAkB,OAAO;AACzB,kBAAkB,OAAO;AACzB,kBAAkB,OAAO;AACzB,kBAAkB,OAAO;AACzB;AACA;AACA;AACA;AACA;AACA,sBAAsB,UAAU;AAChC;AACA;;AAEA;AACA;AACA;AACA,mBAAmB,UAAU;AAC7B,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA,6EAA6E,kBAAkB;AAC/F;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,UAAU;AAC7B,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA,6EAA6E,kBAAkB;AAC/F;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B,mBAAmB,UAAU;AAC7B,mBAAmB,OAAO;AAC1B;AACA;AACA;AACA,uGAAuG,kBAAkB;AACzH;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,iBAAiB;AACpC;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA,mBAAmB,iBAAiB;AACpC;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,SAAS;;AAET;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,qBAAqB;;AAErB;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;;AAEL;AACA;AACA;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS;;AAET;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B,mBAAmB,MAAM;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B,mBAAmB,MAAM;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B,mBAAmB,MAAM;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,MAAM;AAC7B,uBAAuB,OAAO;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,MAAM;AAC7B,uBAAuB,OAAO;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,aAAa;AACb;AACA;;AAEA;AACA,2BAA2B,eAAe;AAC1C;AACA;AACA;;AAEA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,MAAM;AAC7B,uBAAuB,OAAO;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,MAAM;AAC7B,uBAAuB,OAAO;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,SAAS;;AAET;AACA,2BAA2B,eAAe;AAC1C;AACA;AACA;;AAEA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,UAAU;AAC7B,mBAAmB,OAAO;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,2BAA2B,mBAAmB;AAC9C;AACA;AACA;;AAEA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,UAAU;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,SAAS;;AAET;AACA;AACA;;;AAGA;AACA;AACA;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;AACA;AACA;AACA,sBAAsB,KAAK;AAC3B,sBAAsB,QAAQ;AAC9B;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa;AACb;;AAEA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA,SAAS;;AAET;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,aAAa;AACb;AACA;;AAEA;AACA;AACA;;AAEA;AACA,SAAS;;AAET;AACA,KAAK;;AAEL;AACA;AACA;AACA,kBAAkB,UAAU;AAC5B,kBAAkB,UAAU;AAC5B,kBAAkB,UAAU;AAC5B,kBAAkB,UAAU;AAC5B,kBAAkB,OAAO;AACzB,kBAAkB,KAAK;AACvB,kBAAkB,QAAQ;AAC1B,kBAAkB,OAAO;AACzB,kBAAkB,OAAO;AACzB;AACA;AACA;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,aAAa;AAChC;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa;AACb;AACA;;AAEA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,aAAa;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,wCAAwC,qCAAqC;AAC7E;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,UAAU;AAChC;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B,mBAAmB,iBAAiB;AACpC,mBAAmB,UAAU;AAC7B,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,aAAa;AACjC;AACA;AACA;AACA;AACA;AACA;AACA,gHAAgH,SAAS;AACzH,gHAAgH,0CAA0C;AAC1J;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B,mBAAmB,oBAAoB;AACvC,mBAAmB,UAAU;AAC7B,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA,qHAAqH,0CAA0C;AAC/J,kHAAkH,0CAA0C;AAC5J;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA,mBAAmB,oBAAoB;AACvC,mBAAmB,UAAU;AAC7B;AACA,oBAAoB,aAAa;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B,mBAAmB,OAAO;AAC1B,mBAAmB,OAAO;AAC1B,mBAAmB,iBAAiB;AACpC;AACA,oBAAoB,aAAa;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,qCAAqC,4BAA4B;;AAEjE;AACA;AACA;;AAEA;AACA,wCAAwC,+BAA+B;AACvE;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,IAAI;AAC1B;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B,mBAAmB,iBAAiB;AACpC,mBAAmB,OAAO;AAC1B,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,aAAa;AACjC;AACA;AACA;AACA;AACA;AACA;AACA,wHAAwH,kCAAkC;AAC1J;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B,mBAAmB,oBAAoB;AACvC,mBAAmB,OAAO;AAC1B,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA,6HAA6H,kCAAkC;AAC/J,0HAA0H,kCAAkC;AAC5J;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,KAAK;AACL,CAAC;;;;;;;AC98BD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,UAAU;AAC7B;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,2BAA2B,cAAc;AACzC;AACA;AACA;;AAEA;;AAEA,+BAA+B,sCAAsC;AACrE;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,2BAA2B,qBAAqB;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;AACA,CAAC;;;;;;;AC9GD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,OAAO;AAC7B,sBAAsB,OAAO;AAC7B,sBAAsB,OAAO;AAC7B;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,OAAO;AAC1B;AACA;AACA;AACA;AACA,sDAAsD,aAAa;AACnE,sDAAsD,+BAA+B;AACrF;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,iBAAiB;AACpC,mBAAmB,iBAAiB;AACpC;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,+BAA+B,gBAAgB;AAC/C;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA,eAAe,iBAAiB;AAChC,eAAe,iBAAiB;AAChC,eAAe,OAAO;AACtB;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,aAAa;AACnE,sDAAsD,+BAA+B;AACrF;AACA;AACA;AACA;AACA,CAAC;;;;;;;ACvHD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,EAAE;;AAEF;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,sC;;;;;;AC7CA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,uBAAuB,QAAQ;AAC/B;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA,2BAA2B,QAAQ;AACnC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,2BAA2B,OAAO;AAClC;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,SAAS;;AAET;AACA;AACA;;AAEA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,eAAe,iBAAiB;AAChC;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,eAAe,iBAAiB;AAChC,eAAe,iBAAiB;AAChC;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;;;;;AC/PD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,gCAAgC,iBAAiB;AACjD;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,KAAK;;AAEL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,2BAA2B,QAAQ;AACnC;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,SAAS;;AAET;AACA;AACA;;AAEA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA,eAAe,iBAAiB;AAChC;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,eAAe,iBAAiB;AAChC,eAAe,iBAAiB;AAChC;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,Q;;;;;;;;;;;;;;;;;;;;;ACpLD;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACO,IAAIS,MAAI,CAAR,C,CAAmB;AAC1B,IAAIC,OAAK,CAAT,C,CAAmB;AACnB,IAAIC,QAAMD,OAAK,CAAf,C,CAAmB;;AAEnB;AACA,IAAIE,YAAU,oGAAd;;AAEA;AACA,KAAKH,MAAI,CAAT,EAAa,KAAIA,MAAI,CAAT,GAAgB,KAAGA,GAA/B,EAAqCA,KAArC,CAA2C,C,CAAG;AAC9CA,QAAM,CAAN,C,CAA2B;AAC3BC,OAAK,CAAC,KAAGD,GAAJ,IAAS,CAAd,C,CAA2B;AAC3BE,QAAMD,OAAK,CAAX,C,CAA2B;AACpB,IAAIG,MAAIC,WAAW,CAAX,EAAa,CAAb,EAAe,CAAf,CAAR,C,CAA+B;;AAEtC;AACA;AACA,IAAIC,IAAE,IAAIjI,KAAJ,CAAU,CAAV,CAAN;AACA,IAAIkI,KAAGD,CAAP,C,CAAgB;AAChB,IAAIE,KAAGF,CAAP,C,CAAgB;AAChB,IAAIG,KAAGH,CAAP,C,CAAgB;AAChB,IAAII,KAAGJ,CAAP,C,CAAgB;AAChB,IAAIK,KAAGL,CAAP,C,CAAgB;AAChB,IAAIM,KAAGN,CAAP;AAAA,IAAUO,KAAGP,CAAb,C,CAAgB;AAChB,IAAIQ,KAAGR,CAAP,C,CAAgB;AAChB,IAAIS,KAAGT,CAAP,C,CAAgB;AAChB,IAAIU,IAAEV,CAAN,C,CAAgB;AAChB,IAAIW,KAAGX,CAAP,C,CAAgB;AAChB,IAAIY,QAAMZ,CAAV;AAAA,IAAaa,OAAKb,CAAlB;AAAA,IAAqBc,OAAKd,CAA1B;AAAA,IAAkE;AAClEe,OAAKf,CADL;AAAA,IACQgB,OAAKhB,CADb;AAAA,IACgBiB,OAAKjB,CADrB;AAAA,IACwBkB,OAAKlB,CAD7B;AAAA,IACgCmB,OAAKnB,CADrC;AAAA,IACwCoB,OAAKpB,CAD7C;AAAA,IAC8D;AAC9DqB,QAAMrB,CAFN;AAAA,IAESsB,QAAMtB,CAFf;AAAA,IAEkBuB,QAAMvB,CAFxB;AAAA,IAE2BwB,OAAKxB,CAFhC;AAAA,IAEmCyB,QAAMzB,CAFzC;AAAA,IAE4C0B,QAAM1B,CAFlD;AAAA,IAEqD2B,QAAM3B,CAF3D;AAAA,IAE8D;;AAE9D4B,SAAO5B,CAJP;AAAA,IAIU6B,OAAK7B,CAJf;AAAA,IAIkB8B,MAAI9B,CAJtB;AAAA,IAIyB+B,OAAK/B,CAJ9B;AAAA,IAIiCgC,MAAIhC,CAJrC;AAAA,IAIwCiC,OAAKjC,CAJ7C;AAAA,IAIgDkC,MAAIlC,CAJpD;AAAA,IAIuDmC,OAAKnC,CAJ5D;AAAA,IAKEoC,MAAIpC,CALN;AAAA,IAKSqC,OAAKrC,CALd;AAAA,IAKiBsC,MAAItC,CALrB;AAAA,IAKwBuC,MAAIvC,CAL5B;AAAA,IAK+BwC,MAAIxC,CALnC;AAAA,IAKsCyC,OAAKzC,CAL3C;AAAA,IAK8C0C,OAAK1C,CALnD;AAAA,IAKsD2C,OAAK3C,CAL3D;AAAA,IAK8D;;AAE9D4C,QAAM5C,CAPN,C,CAOS;;AAET;;AAEA,IAAI6C,CAAJ,EAAOC,IAAP;;AAEA;AACA,SAASC,UAAT,CAAoBC,CAApB,EAAuB;AACrB,MAAI5O,CAAJ,EAAM6O,CAAN,EAAQC,CAAR,EAAUC,GAAV;AACAF,MAAE,IAAIlL,KAAJ,CAAUiL,CAAV,CAAF;AACA,OAAK5O,IAAE,CAAP,EAASA,IAAE4O,CAAX,EAAa5O,GAAb,EACE6O,EAAE7O,CAAF,IAAK,CAAL;AACF6O,IAAE,CAAF,IAAK,CAAL;AACAC,MAAE,CAAF,CANqB,CAMb;AACR,SAAKD,EAAEC,CAAF,IAAKF,CAAV,GAAc;AAAmB;AAC/B,SAAI5O,IAAE6O,EAAEC,CAAF,IAAKD,EAAEC,CAAF,CAAX,EAAiB9O,IAAE4O,CAAnB,EAAsB5O,KAAG6O,EAAEC,CAAF,CAAzB,EAA+B;AAC7BD,MAAE7O,CAAF,IAAK,CAAL;AACF8O;AACAD,MAAEC,CAAF,IAAKD,EAAEC,IAAE,CAAJ,IAAO,CAAZ;AACA,WAAMD,EAAEC,CAAF,IAAKF,CAAL,IAAUC,EAAEA,EAAEC,CAAF,CAAF,CAAhB,EAAyBD,EAAEC,CAAF,GAAzB,CAAgC,CALpB,CAKsB;AACnC;AACDC,QAAI,IAAIpL,KAAJ,CAAUmL,CAAV,CAAJ;AACA,OAAI9O,IAAE,CAAN,EAAQA,IAAE8O,CAAV,EAAY9O,GAAZ,EACE+O,IAAI/O,CAAJ,IAAO6O,EAAE7O,CAAF,CAAP;AACF,SAAO+O,GAAP;AACD;;AAGD;AACA;AACA,SAASC,cAAT,CAAwBrG,CAAxB,EAA0BxF,CAA1B,EAA6B;AAC3B,MAAIqJ,MAAMvM,MAAN,IAAc0I,EAAE1I,MAApB,EAA4B;AAC1BuM,YAAMyC,IAAItG,CAAJ,CAAN;AACA8D,WAAKwC,IAAItG,CAAJ,CAAL;AACA+D,WAAKuC,IAAItG,CAAJ,CAAL;AACD;;AAEDuB,WAASwC,IAAT,EAAcvJ,CAAd;AACA,SAAO+L,YAAYvG,CAAZ,EAAc+D,IAAd,CAAP;AACD;;AAED;AACA;AACA,SAASwC,WAAT,CAAqBvG,CAArB,EAAuBxF,CAAvB,EAA0B;AACxB,MAAInD,CAAJ,EAAM+I,CAAN,EAAQ0F,CAAR,EAAUI,CAAV;;AAEA,MAAIrC,MAAMvM,MAAN,IAAc0I,EAAE1I,MAApB,EAA4B;AAC1BuM,YAAMyC,IAAItG,CAAJ,CAAN;AACA8D,WAAKwC,IAAItG,CAAJ,CAAL;AACA+D,WAAKuC,IAAItG,CAAJ,CAAL;AACD;;AAEDwB,QAAMuC,IAAN,EAAWvJ,CAAX;AACAgH,QAAMsC,IAAN,EAAW9D,CAAX;AACAwB,QAAMqC,KAAN,EAAY7D,CAAZ;;AAEAwG,UAAQ1C,IAAR,EAAa,CAAC,CAAd;AACA0C,UAAQ3C,KAAR,EAAc,CAAC,CAAf;;AAEA;AACAiC,MAAE,CAAF;AACA,OAAKzO,IAAE,CAAP,EAASA,IAAEyM,KAAKxM,MAAhB,EAAuBD,GAAvB,EACE,KAAK+I,IAAE,CAAP,EAASA,IAAEwC,IAAX,EAAgBxC,MAAI,CAApB,EACE,IAAIJ,EAAE3I,CAAF,IAAO+I,CAAX,EAAc;AACZ8F,QAAGJ,IAAEhC,KAAKxM,MAAL,GAAYqL,GAAd,GAAoBmD,CAApB,GAAwB,CAA3B;AACCzO,QAAEyM,KAAKxM,MAAP;AACA8I,QAAEwC,IAAF;AACF,GAJD,MAKEkD;;AAEN,MAAII,CAAJ,EACErE,YAAYiC,IAAZ,EAAiBoC,CAAjB;;AAEFO,UAAQ1C,IAAR,EAAaD,IAAb,EAAkB9D,CAAlB;;AAEA,MAAI,CAAC+B,UAAUgC,IAAV,EAAe,CAAf,CAAD,IAAsB,CAACxD,OAAOwD,IAAP,EAAYF,KAAZ,CAA3B,EAA+C;AAC7CzD,QAAE,CAAF;AACA,WAAOA,KAAG8F,IAAE,CAAL,IAAU,CAAC3F,OAAOwD,IAAP,EAAYF,KAAZ,CAAlB,EAAsC;AACpC6C,iBAAW3C,IAAX,EAAgB/D,CAAhB;AACA,UAAI+B,UAAUgC,IAAV,EAAe,CAAf,CAAJ,EAAuB;AACrB,eAAO,CAAP;AACD;AACD3D;AACD;AACD,QAAI,CAACG,OAAOwD,IAAP,EAAYF,KAAZ,CAAL,EAAyB;AACvB,aAAO,CAAP;AACD;AACF;AACD,SAAO,CAAP;AACD;;AAED;AACA,SAAS8C,OAAT,CAAiB3G,CAAjB,EAAoB;AAClB,MAAII,CAAJ,EAAMW,CAAN,EAAQ6F,CAAR;AACA,OAAKxG,IAAEJ,EAAE1I,MAAF,GAAS,CAAhB,EAAoB0I,EAAEI,CAAF,KAAM,CAAP,IAAcA,IAAE,CAAnC,EAAuCA,GAAvC,CAA2C;AAC3C,OAAKW,IAAE,CAAF,EAAI6F,IAAE5G,EAAEI,CAAF,CAAX,EAAiBwG,CAAjB,EAAqBA,MAAI,CAAL,EAAQ7F,GAA5B,CAAgC;AAChCA,OAAG4B,MAAIvC,CAAP;AACA,SAAOW,CAAP;AACD;;AAED;AACA,SAAS8F,MAAT,CAAgB7G,CAAhB,EAAkBiG,CAAlB,EAAqB;AACnB,MAAIG,MAAIpD,WAAW,CAAX,EAAa,CAAChD,EAAE1I,MAAF,GAAS2O,CAAT,GAAajG,EAAE1I,MAAf,GAAwB2O,CAAzB,IAA4BtD,GAAzC,EAA6C,CAA7C,CAAR;AACAnB,QAAM4E,GAAN,EAAUpG,CAAV;AACA,SAAOoG,GAAP;AACD;;AAED;AACA,SAASU,aAAT,CAAuBhB,CAAvB,EAA0B;AACxB,MAAIM,MAAIpD,WAAW,CAAX,EAAa8C,CAAb,EAAe,CAAf,CAAR;AACAiB,iBAAeX,GAAf,EAAmBN,CAAnB;AACA,SAAOkB,KAAKZ,GAAL,EAAS,CAAT,CAAP;AACD;;AAED;AACA,SAASa,aAAT,CAAuBnB,CAAvB,EAA0B;AACxB,MAAIA,KAAG,GAAP,EAAY,OAAOoB,oBAAoBpB,CAApB,EAAsB,CAAtB,CAAP,CADY,CACqB;AAC7C,MAAIA,KAAG,GAAP,EAAY,OAAOoB,oBAAoBpB,CAApB,EAAsB,CAAtB,CAAP;AACZ,MAAIA,KAAG,GAAP,EAAY,OAAOoB,oBAAoBpB,CAApB,EAAsB,CAAtB,CAAP;AACZ,MAAIA,KAAG,GAAP,EAAY,OAAOoB,oBAAoBpB,CAApB,EAAsB,CAAtB,CAAP;AACZ,MAAIA,KAAG,GAAP,EAAY,OAAOoB,oBAAoBpB,CAApB,EAAsB,CAAtB,CAAP;AACZ,MAAIA,KAAG,GAAP,EAAY,OAAOoB,oBAAoBpB,CAApB,EAAsB,CAAtB,CAAP;AACZ,MAAIA,KAAG,GAAP,EAAY,OAAOoB,oBAAoBpB,CAApB,EAAsB,EAAtB,CAAP,CAPY,CAOsB;AAC9C,MAAIA,KAAG,GAAP,EAAY,OAAOoB,oBAAoBpB,CAApB,EAAsB,EAAtB,CAAP;AACZ,MAAIA,KAAG,GAAP,EAAY,OAAOoB,oBAAoBpB,CAApB,EAAsB,EAAtB,CAAP;AACZ,MAAIA,KAAG,GAAP,EAAY,OAAOoB,oBAAoBpB,CAApB,EAAsB,EAAtB,CAAP;AACA,SAAOoB,oBAAoBpB,CAApB,EAAsB,EAAtB,CAAP,CAXY,CAWsB;AAC/C;;AAED;AACA,SAASoB,mBAAT,CAA6BpB,CAA7B,EAA+BG,CAA/B,EAAkC;AAChC,MAAIG,GAAJ,EAAS/O,CAAT,EAAY8P,SAAZ,EAAuBC,CAAvB;AACAA,MAAE,KAAF,CAFgC,CAEtB;AACVhB,QAAIpD,WAAW,CAAX,EAAa8C,CAAb,EAAe,CAAf,CAAJ;;AAEA;;AAEA,MAAIjB,OAAOvN,MAAP,IAAe,CAAnB,EACEuN,SAAOmB,WAAW,KAAX,CAAP,CAR8B,CAQH;;AAE7B,MAAIH,MAAMvO,MAAN,IAAc8O,IAAI9O,MAAtB,EACEuO,QAAMS,IAAIF,GAAJ,CAAN;;AAEF,WAAS;AAAE;AACT;AACA;AACA;;AAEAiB,gBAAYjB,GAAZ,EAAgBN,CAAhB,EAAkB,CAAlB,EALO,CAKe;AACtBM,QAAI,CAAJ,KAAU,CAAV;AACAe,gBAAU,CAAV;;AAEA;AACA,SAAK9P,IAAE,CAAP,EAAWA,IAAEwN,OAAOvN,MAAV,IAAsBuN,OAAOxN,CAAP,KAAW+P,CAA3C,EAA+C/P,GAA/C,EACE,IAAIiQ,OAAOlB,GAAP,EAAWvB,OAAOxN,CAAP,CAAX,KAAuB,CAAvB,IAA4B,CAAC0K,UAAUqE,GAAV,EAAcvB,OAAOxN,CAAP,CAAd,CAAjC,EAA2D;AACzD8P,kBAAU,CAAV;AACA;AACD;;AAEH;;AAEA;AACA,SAAK9P,IAAE,CAAP,EAAUA,IAAE4O,CAAF,IAAO,CAACkB,SAAlB,EAA6B9P,GAA7B,EAAkC;AAChCgQ,kBAAYxB,KAAZ,EAAkBC,CAAlB,EAAoB,CAApB;AACA,aAAM,CAACnE,QAAQyE,GAAR,EAAYP,KAAZ,CAAP,EAA2B;AACzBwB,kBAAYxB,KAAZ,EAAkBC,CAAlB,EAAoB,CAApB;AACF,UAAI,CAACS,YAAYH,GAAZ,EAAgBP,KAAhB,CAAL,EACEsB,YAAU,CAAV;AACH;;AAED,QAAG,CAACA,SAAJ,EACE,OAAOf,GAAP;AACH;AACF;;AAED;AACA,SAASmB,GAAT,CAAavH,CAAb,EAAeiG,CAAf,EAAkB;AAChB,MAAIG,MAAIE,IAAItG,CAAJ,CAAR;AACAwH,OAAKpB,GAAL,EAASH,CAAT;AACA,SAAOe,KAAKZ,GAAL,EAAS,CAAT,CAAP;AACD;;AAED;AACA,SAASqB,MAAT,CAAgBzH,CAAhB,EAAkBiG,CAAlB,EAAqB;AACnB,MAAIG,MAAIS,OAAO7G,CAAP,EAASA,EAAE1I,MAAF,GAAS,CAAlB,CAAR;AACAkP,UAAQJ,GAAR,EAAYH,CAAZ;AACA,SAAOe,KAAKZ,GAAL,EAAS,CAAT,CAAP;AACD;;AAED;AACA,SAASsB,IAAT,CAAc1H,CAAd,EAAgBC,CAAhB,EAAmB;AACjB,MAAImG,MAAIS,OAAO7G,CAAP,EAASA,EAAE1I,MAAF,GAAS2I,EAAE3I,MAApB,CAAR;AACAqQ,QAAMvB,GAAN,EAAUnG,CAAV;AACA,SAAO+G,KAAKZ,GAAL,EAAS,CAAT,CAAP;AACD;;AAED;AACO,SAAS7D,MAAT,CAAgBvC,CAAhB,EAAkBC,CAAlB,EAAoBgG,CAApB,EAAuB;AAC5B,MAAIG,MAAIS,OAAO7G,CAAP,EAASiG,EAAE3O,MAAX,CAAR;AACAmP,UAAQL,GAAR,EAAYY,KAAK/G,CAAL,EAAO,CAAP,CAAZ,EAAsB+G,KAAKf,CAAL,EAAO,CAAP,CAAtB,EAAgC,CAAhC,EAF4B,CAES;AACrC,SAAOe,KAAKZ,GAAL,EAAS,CAAT,CAAP;AACD;;AAED;AACA,SAASwB,GAAT,CAAa5H,CAAb,EAAeC,CAAf,EAAkB;AAChB,MAAImG,MAAIS,OAAO7G,CAAP,EAAUA,EAAE1I,MAAF,GAAS2I,EAAE3I,MAAX,GAAoB0I,EAAE1I,MAAF,GAAS,CAA7B,GAAiC2I,EAAE3I,MAAF,GAAS,CAApD,CAAR;AACAsK,OAAKwE,GAAL,EAASnG,CAAT;AACA,SAAO+G,KAAKZ,GAAL,EAAS,CAAT,CAAP;AACD;;AAED;AACA,SAAS7J,GAAT,CAAayD,CAAb,EAAeC,CAAf,EAAkB;AAChB,MAAImG,MAAIS,OAAO7G,CAAP,EAAUA,EAAE1I,MAAF,GAAS2I,EAAE3I,MAAX,GAAoB0I,EAAE1I,MAAF,GAAS,CAA7B,GAAiC2I,EAAE3I,MAAF,GAAS,CAApD,CAAR;AACAoK,OAAK0E,GAAL,EAASnG,CAAT;AACA,SAAO+G,KAAKZ,GAAL,EAAS,CAAT,CAAP;AACD;;AAED;AACA,SAASyB,UAAT,CAAoB7H,CAApB,EAAsBiG,CAAtB,EAAyB;AACvB,MAAIG,MAAIS,OAAO7G,CAAP,EAASiG,EAAE3O,MAAX,CAAR;AACA,MAAI4O,CAAJ;AACAA,MAAE4B,YAAY1B,GAAZ,EAAgBH,CAAhB,CAAF;AACA,SAAOC,IAAIc,KAAKZ,GAAL,EAAS,CAAT,CAAJ,GAAkB,IAAzB;AACD;;AAED;AACA,SAAS2B,OAAT,CAAiB/H,CAAjB,EAAmBC,CAAnB,EAAqBgG,CAArB,EAAwB;AACtB,MAAIG,MAAIS,OAAO7G,CAAP,EAASiG,EAAE3O,MAAX,CAAR;AACA0Q,WAAS5B,GAAT,EAAanG,CAAb,EAAegG,CAAf;AACA,SAAOe,KAAKZ,GAAL,EAAS,CAAT,CAAP;AACD;;AAED;AACA;AACA,SAASW,cAAT,CAAwBX,GAAxB,EAA4BN,CAA5B,EAA+B;AAC7B,MAAIxF,CAAJ,EAAM4B,CAAN,EAAQ+F,EAAR,EAAWC,EAAX,EAAc9H,CAAd,EAAgB+H,CAAhB,EAAkBf,CAAlB,EAAoBD,SAApB,EAA8BpG,CAA9B,EAAgCqH,EAAhC,EAAmCC,OAAnC;;AAEA,MAAIxD,OAAOvN,MAAP,IAAe,CAAnB,EACEuN,SAAOmB,WAAW,KAAX,CAAP,CAJ2B,CAIA;;AAE7B,MAAIlB,KAAKxN,MAAL,IAAa,CAAjB,EAAoB;AAClBwN,WAAK,IAAI9J,KAAJ,CAAU,GAAV,CAAL;AACA,SAAKoF,IAAE,CAAP,EAASA,IAAE,GAAX,EAAeA,GAAf,EAAoB;AAClB0E,WAAK1E,CAAL,IAAQjB,KAAKmJ,GAAL,CAAS,CAAT,EAAWlI,IAAE,IAAF,GAAO,EAAlB,CAAR;AACD;AACF;;AAED;AACAE,MAAE,GAAF,CAd6B,CAcrB;AACR4B,MAAE,EAAF,CAf6B,CAerB;AACRqG,aAAS,EAAT,CAhB6B,CAgBhB;;AAEb,MAAIvD,KAAK1N,MAAL,IAAa8O,IAAI9O,MAArB,EAA6B;AAC3B0N,WAAKsB,IAAIF,GAAJ,CAAL;AACAnB,UAAKqB,IAAIF,GAAJ,CAAL;AACAhB,WAAKkB,IAAIF,GAAJ,CAAL;AACAd,WAAKgB,IAAIF,GAAJ,CAAL;AACAX,UAAKa,IAAIF,GAAJ,CAAL;AACAV,WAAKY,IAAIF,GAAJ,CAAL;AACAT,WAAKW,IAAIF,GAAJ,CAAL;AACAZ,UAAKc,IAAIF,GAAJ,CAAL;AACAb,UAAKe,IAAIF,GAAJ,CAAL;AACArB,UAAKuB,IAAIF,GAAJ,CAAL;AACAlB,WAAKoB,IAAIF,GAAJ,CAAL;AACAjB,UAAKmB,IAAIF,GAAJ,CAAL;AACAf,UAAKiB,IAAIF,GAAJ,CAAL;AACAR,WAAKU,IAAIF,GAAJ,CAAL;AACD;;AAED,MAAIN,KAAKyC,QAAT,EAAmB;AAAG;AACpBN,SAAG,CAAC,MAAKnC,IAAE,CAAH,IAAO,CAAX,CAAD,IAAgB,CAAnB,CADiB,CACK;AACtBvE,aAAS6E,GAAT,EAAa,CAAb;AACA,SAAK8B,KAAG,CAAR,EAAUA,EAAV,GAAe;AACbA,WAAG,CAAH;AACA9B,UAAI,CAAJ,IAAQ,IAAK,KAAIN,IAAE,CAAX,GAAiB3G,KAAKC,KAAL,CAAWD,KAAKE,MAAL,MAAe,KAAGyG,CAAlB,CAAX,CAAzB,CAFa,CAE+C;AAC5D,WAAK1F,IAAE,CAAP,EAAUA,IAAEyE,OAAOvN,MAAV,IAAsB,CAACuN,OAAOzE,CAAP,IAAU6H,EAAX,KAAgBpD,OAAOzE,CAAP,CAA/C,EAA0DA,GAA1D,EAA+D;AAAE;AAC/D,YAAI,KAAIgG,IAAI,CAAJ,IAAOvB,OAAOzE,CAAP,CAAf,EAA2B;AACzB8H,eAAG,CAAH;AACA;AACD;AACF;AACF;AACDM,WAAOpC,GAAP;AACA;AACD;;AAEDgB,MAAE9G,IAAEwF,CAAF,GAAIA,CAAN,CApD6B,CAoDjB;AACZ,MAAIA,IAAE,IAAE5D,CAAR,EAAY;AACV,SAAKiG,IAAE,CAAP,EAAUrC,IAAEA,IAAEqC,CAAJ,IAAOjG,CAAjB,GACEiG,IAAErD,KAAK3F,KAAKC,KAAL,CAAWD,KAAKE,MAAL,KAAc,GAAzB,CAAL,CAAF,CAFJ,CAE6C;AAF7C,OAIE8I,IAAE,EAAF;;AAEF;;AAEAE,YAAQlJ,KAAKC,KAAL,CAAW+I,IAAErC,CAAb,IAAgB,CAAxB;;AAEAiB,iBAAe5B,GAAf,EAAmBkD,OAAnB;AACA9G,WAASyD,IAAT,EAAc,CAAd;AACAA,OAAK7F,KAAKC,KAAL,CAAW,CAAC0G,IAAE,CAAH,IAAMnD,GAAjB,CAAL,KAAgC,KAAI,CAACmD,IAAE,CAAH,IAAMnD,GAA1C,CAjE6B,CAiEsB;AACnDX,UAAQgD,IAAR,EAAaG,GAAb,EAAiBJ,GAAjB,EAAqBG,IAArB,EAlE6B,CAkEsB;;AAEnDnE,MAAE4F,QAAQ5B,GAAR,CAAF;;AAEA,WAAS;AACP,aAAS;AAAG;AACVsC,kBAAYpC,GAAZ,EAAgBlE,CAAhB,EAAkB,CAAlB;AACA,UAAIY,QAAQoD,GAAR,EAAYE,GAAZ,CAAJ,EACE;AACH,KALM,CAKU;AACjBuB,YAAQvB,GAAR,EAAY,CAAZ,EANO,CAMU;AACjBvD,SAAKuD,GAAL,EAASF,GAAT,EAPO,CAOU;;AAEjBvD,UAAM+D,GAAN,EAAUJ,GAAV;AACAwC,UAAMpC,GAAN,EAAUN,GAAV;AACAwD,aAASlD,GAAT,EAAa,CAAb;AACAiB,YAAQjB,GAAR,EAAY,CAAZ,EAZO,CAYY;;AAEnB/D,UAAM8D,IAAN,EAAWL,GAAX;AACAwD,aAASnD,IAAT,EAAc,CAAd,EAfO,CAeY;;AAEnB;AACA,SAAK6B,YAAU,CAAV,EAAY/G,IAAE,CAAnB,EAAuBA,IAAEyE,OAAOvN,MAAV,IAAsBuN,OAAOzE,CAAP,IAAUgH,CAAtD,EAA0DhH,GAA1D,EACE,IAAIkH,OAAO/B,GAAP,EAAWV,OAAOzE,CAAP,CAAX,KAAuB,CAAvB,IAA4B,CAAC2B,UAAUwD,GAAV,EAAcV,OAAOzE,CAAP,CAAd,CAAjC,EAA2D;AACzD+G,kBAAU,CAAV;AACA;AACD;;AAEH,QAAI,CAACA,SAAL,EAAmB;AACjB,UAAI,CAACd,eAAed,GAAf,EAAmB,CAAnB,CAAL,EAA4B;AAC1B4B,oBAAU,CAAV;;AAEJ,QAAI,CAACA,SAAL,EAAgB;AAAG;AACjBX,cAAQjB,GAAR,EAAY,CAAC,CAAb;AACA,WAAKnF,IAAEmF,IAAIjO,MAAJ,GAAW,CAAlB,EAAqBiO,IAAInF,CAAJ,KAAQ,CAAT,IAAgBA,IAAE,CAAtC,EAA0CA,GAA1C,CAA8C,CAFhC,CAEmC;AACjD,WAAKgI,KAAG,CAAH,EAAKxB,IAAErB,IAAInF,CAAJ,CAAZ,EAAoBwG,CAApB,EAAwBA,MAAI,CAAL,EAAQwB,IAA/B,CAAoC;AACpCA,YAAIzF,MAAIvC,CAAR,CAJc,CAIyB;AACvC,eAAS;AAAG;AACViH,oBAAYhC,GAAZ,EAAgB+C,EAAhB,EAAmB,CAAnB;AACA,YAAIzG,QAAQ4D,GAAR,EAAYF,GAAZ,CAAJ,EACE;AACH,OATa,CASG;AACjBmB,cAAQjB,GAAR,EAAY,CAAZ,EAVc,CAUG;AACjBiB,cAAQnB,GAAR,EAAY,CAAZ,EAXc,CAWG;AACjB7D,YAAMgE,GAAN,EAAUH,GAAV;AACA7D,YAAM4D,IAAN,EAAWG,GAAX;AACAiB,cAAQpB,IAAR,EAAa,CAAC,CAAd;AACAqB,cAAQjB,GAAR,EAAYJ,IAAZ,EAAiBG,GAAjB,EAfc,CAeW;AACzBiB,cAAQhB,GAAR,EAAY,CAAC,CAAb;AACA,UAAI/D,OAAO+D,GAAP,CAAJ,EAAiB;AACfhE,cAAMgE,GAAN,EAAUH,GAAV;AACAoB,gBAAQjB,GAAR,EAAYF,IAAZ,EAAiBC,GAAjB;AACAiB,gBAAQhB,GAAR,EAAY,CAAC,CAAb;AACAhE,cAAMoE,IAAN,EAAWL,GAAX;AACA/D,cAAMiE,GAAN,EAAUD,GAAV;AACAkD,aAAKjD,GAAL,EAASF,GAAT,EANe,CAMC;AAChB,YAAIxD,UAAU0D,GAAV,EAAc,CAAd,CAAJ,EAAsB;AACpBjE,gBAAM4E,GAAN,EAAUR,IAAV;AACA,iBAFoB,CAER;AACb;AACF;AACF;AACF;AACF;;AAED;AACA,SAAS+C,UAAT,CAAoB1C,CAApB,EAAsBC,CAAtB,EAAyB;AACvB,MAAI7F,CAAJ,EAAM7F,CAAN;AACA6F,MAAElB,KAAKC,KAAL,CAAW,CAAC6G,IAAE,CAAH,IAAMtD,GAAjB,IAAsB,CAAxB,CAFuB,CAEI;AAC3BnI,MAAEwI,WAAW,CAAX,EAAa,CAAb,EAAe3C,CAAf,CAAF;AACAgH,cAAY7M,CAAZ,EAAcyL,CAAd,EAAgBC,CAAhB;AACA,SAAO1L,CAAP;AACD;;AAED;AACA;AACA,SAAS6M,WAAT,CAAqB7M,CAArB,EAAuByL,CAAvB,EAAyBC,CAAzB,EAA4B;AAC1B,MAAI7O,CAAJ,EAAMgJ,CAAN;AACA,OAAKhJ,IAAE,CAAP,EAASA,IAAEmD,EAAElD,MAAb,EAAoBD,GAApB,EACEmD,EAAEnD,CAAF,IAAK,CAAL;AACFgJ,MAAElB,KAAKC,KAAL,CAAW,CAAC6G,IAAE,CAAH,IAAMtD,GAAjB,IAAsB,CAAxB,CAJ0B,CAIC;AAC3B,OAAKtL,IAAE,CAAP,EAASA,IAAEgJ,CAAX,EAAahJ,GAAb,EAAkB;AAChBmD,MAAEnD,CAAF,IAAK8H,KAAKC,KAAL,CAAWD,KAAKE,MAAL,MAAe,KAAIsD,MAAI,CAAvB,CAAX,CAAL;AACD;AACDnI,IAAE6F,IAAE,CAAJ,KAAU,CAAC,KAAI,CAAC4F,IAAE,CAAH,IAAMtD,GAAX,IAAiB,CAA3B;AACA,MAAIuD,KAAG,CAAP,EACE1L,EAAE6F,IAAE,CAAJ,KAAW,KAAI,CAAC4F,IAAE,CAAH,IAAMtD,GAArB;AACH;;AAED;AACA,SAASiG,GAAT,CAAa5I,CAAb,EAAeC,CAAf,EAAkB;AAChB,MAAI4I,EAAJ,EAAOC,EAAP;AACAD,OAAGvC,IAAItG,CAAJ,CAAH;AACA8I,OAAGxC,IAAIrG,CAAJ,CAAH;AACAyI,OAAKG,EAAL,EAAQC,EAAR;AACA,SAAOD,EAAP;AACD;;AAED;AACA;AACA,SAASH,IAAT,CAAc1I,CAAd,EAAgBC,CAAhB,EAAmB;AACjB,MAAI5I,CAAJ,EAAM0R,EAAN,EAASC,EAAT,EAAYC,CAAZ,EAAc7B,CAAd,EAAgB8B,CAAhB,EAAkBC,CAAlB,EAAoBpJ,CAApB,EAAsBqJ,IAAtB;AACA,MAAIzF,EAAErM,MAAF,IAAU0I,EAAE1I,MAAhB,EACEqM,IAAE2C,IAAItG,CAAJ,CAAF;;AAEFoJ,SAAK,CAAL;AACA,SAAOA,IAAP,EAAa;AAAE;AACbA,WAAK,CAAL;AACA,SAAK/R,IAAE,CAAP,EAASA,IAAE4I,EAAE3I,MAAb,EAAoBD,GAApB,EAAyB;AACvB,QAAI4I,EAAE5I,CAAF,CAAJ,EAAU;AACR+R,aAAK,CAAL;AACA;AACD;AACH,QAAI,CAACA,IAAL,EAAW,MAPA,CAOO;;AAElB,SAAK/R,IAAE2I,EAAE1I,MAAT,EAAgB,CAAC0I,EAAE3I,CAAF,CAAD,IAASA,KAAG,CAA5B,EAA8BA,GAA9B,CAAkC,CATvB,CAS0B;AACrC0R,SAAG/I,EAAE3I,CAAF,CAAH;AACA2R,SAAG/I,EAAE5I,CAAF,CAAH;AACA4R,QAAE,CAAF,CAAK7B,IAAE,CAAF,CAAK8B,IAAE,CAAF,CAAKC,IAAE,CAAF;AACf,WAAQH,KAAGE,CAAJ,IAAWF,KAAGG,CAArB,EAAyB;AACvBpJ,UAAGZ,KAAKC,KAAL,CAAW,CAAC2J,KAAGE,CAAJ,KAAQD,KAAGE,CAAX,CAAX,CAAH;AACAG,WAAGlK,KAAKC,KAAL,CAAW,CAAC2J,KAAG3B,CAAJ,KAAQ4B,KAAGG,CAAX,CAAX,CAAH;AACA,UAAIpJ,KAAGsJ,EAAP,EACE;AACFpG,UAAGgG,IAAElJ,IAAEmJ,CAAP,CAAYD,IAAEC,CAAF,CAAOA,IAAEjG,CAAF,CALI,CAKI;AAC3BA,UAAGmE,IAAErH,IAAEoJ,CAAP,CAAY/B,IAAE+B,CAAF,CAAOA,IAAElG,CAAF;AACnBA,UAAE8F,KAAGhJ,IAAEiJ,EAAP,CAAWD,KAAGC,EAAH,CAAOA,KAAG/F,CAAH;AACnB;AACD,QAAImE,CAAJ,EAAO;AACL5F,YAAMmC,CAAN,EAAQ3D,CAAR;AACAsJ,eAAStJ,CAAT,EAAWC,CAAX,EAAagJ,CAAb,EAAe7B,CAAf,EAFK,CAEc;AACnBkC,eAASrJ,CAAT,EAAW0D,CAAX,EAAawF,CAAb,EAAeD,CAAf,EAHK,CAGc;AACpB,KAJD,MAIO;AACL1B,WAAKxH,CAAL,EAAOC,CAAP;AACAuB,YAAMmC,CAAN,EAAQ3D,CAAR;AACAwB,YAAMxB,CAAN,EAAQC,CAAR;AACAuB,YAAMvB,CAAN,EAAQ0D,CAAR;AACD;AACF;AACD,MAAI1D,EAAE,CAAF,KAAM,CAAV,EACE;AACFgD,MAAEqE,OAAOtH,CAAP,EAASC,EAAE,CAAF,CAAT,CAAF;AACAsB,WAASvB,CAAT,EAAWC,EAAE,CAAF,CAAX;AACAA,IAAE,CAAF,IAAKgD,CAAL;AACA,SAAOhD,EAAE,CAAF,CAAP,EAAa;AACXD,MAAE,CAAF,KAAMC,EAAE,CAAF,CAAN;AACAgD,QAAEjD,EAAE,CAAF,CAAF,CAAQA,EAAE,CAAF,IAAKC,EAAE,CAAF,CAAL,CAAWA,EAAE,CAAF,IAAKgD,CAAL;AACpB;AACF;;AAED;AACA;AACA;AACA,SAAS6E,WAAT,CAAqB9H,CAArB,EAAuBiG,CAAvB,EAA0B;AACxB,MAAIH,IAAE,IAAE,IAAE3G,KAAKoK,GAAL,CAASvJ,EAAE1I,MAAX,EAAkB2O,EAAE3O,MAApB,CAAV;;AAEA,MAAG,EAAE0I,EAAE,CAAF,IAAK,CAAP,KAAc,EAAEiG,EAAE,CAAF,IAAK,CAAP,CAAjB,EAA4B;AAAG;AAC7B1E,aAASvB,CAAT,EAAW,CAAX;AACA,WAAO,CAAP;AACD;;AAED,MAAIiE,KAAK3M,MAAL,IAAawO,CAAjB,EAAoB;AAClB7B,WAAK,IAAIjJ,KAAJ,CAAU8K,CAAV,CAAL;AACA9B,WAAK,IAAIhJ,KAAJ,CAAU8K,CAAV,CAAL;AACA5B,WAAK,IAAIlJ,KAAJ,CAAU8K,CAAV,CAAL;AACA3B,WAAK,IAAInJ,KAAJ,CAAU8K,CAAV,CAAL;AACA1B,WAAK,IAAIpJ,KAAJ,CAAU8K,CAAV,CAAL;AACAzB,WAAK,IAAIrJ,KAAJ,CAAU8K,CAAV,CAAL;AACD;;AAEDtE,QAAMyC,IAAN,EAAWjE,CAAX;AACAwB,QAAMwC,IAAN,EAAWiC,CAAX;AACA1E,WAAS2C,IAAT,EAAc,CAAd;AACA3C,WAAS4C,IAAT,EAAc,CAAd;AACA5C,WAAS6C,IAAT,EAAc,CAAd;AACA7C,WAAS8C,IAAT,EAAc,CAAd;AACA,WAAS;AACP,WAAM,EAAEJ,KAAK,CAAL,IAAQ,CAAV,CAAN,EAAoB;AAAG;AACrBuF,aAAOvF,IAAP;AACA,UAAI,EAAEC,KAAK,CAAL,IAAQ,CAAV,KAAgB,EAAEC,KAAK,CAAL,IAAQ,CAAV,CAApB,EAAkC;AAAE;AAClCqF,eAAOtF,IAAP;AACAsF,eAAOrF,IAAP;AACD,OAHD,MAGO;AACLzC,aAAKwC,IAAL,EAAU+B,CAAV,EAAeuD,OAAOtF,IAAP;AACftC,aAAKuC,IAAL,EAAUnE,CAAV,EAAewJ,OAAOrF,IAAP;AAChB;AACF;;AAED,WAAO,EAAEH,KAAK,CAAL,IAAQ,CAAV,CAAP,EAAqB;AAAG;AACtBwF,aAAOxF,IAAP;AACA,UAAI,EAAEI,KAAK,CAAL,IAAQ,CAAV,KAAgB,EAAEC,KAAK,CAAL,IAAQ,CAAV,CAApB,EAAkC;AAAE;AAClCmF,eAAOpF,IAAP;AACAoF,eAAOnF,IAAP;AACD,OAHD,MAGO;AACL3C,aAAK0C,IAAL,EAAU6B,CAAV,EAAeuD,OAAOpF,IAAP;AACfxC,aAAKyC,IAAL,EAAUrE,CAAV,EAAewJ,OAAOnF,IAAP;AAChB;AACF;;AAED,QAAI,CAAC1C,QAAQqC,IAAR,EAAaC,IAAb,CAAL,EAAyB;AAAE;AACzBrC,WAAKqC,IAAL,EAAUD,IAAV;AACApC,WAAKsC,IAAL,EAAUE,IAAV;AACAxC,WAAKuC,IAAL,EAAUE,IAAV;AACD,KAJD,MAIO;AAAoB;AACzBzC,WAAKoC,IAAL,EAAUC,IAAV;AACArC,WAAKwC,IAAL,EAAUF,IAAV;AACAtC,WAAKyC,IAAL,EAAUF,IAAV;AACD;;AAED,QAAIpC,UAAUkC,IAAV,EAAe,CAAf,CAAJ,EAAuB;AACrB,aAAOwF,SAASrF,IAAT,CAAP,EAAuB;AACrB1C,WAAK0C,IAAL,EAAU6B,CAAV;AACFzE,YAAMxB,CAAN,EAAQoE,IAAR;;AAEA,UAAI,CAACrC,UAAUiC,IAAV,EAAe,CAAf,CAAL,EAAwB;AAAE;AACxBzC,iBAASvB,CAAT,EAAW,CAAX;AACA,eAAO,CAAP;AACD;AACD,aAAO,CAAP;AACD;AACF;AACF;;AAED;AACA,SAAS0J,aAAT,CAAuB1J,CAAvB,EAAyBiG,CAAzB,EAA4B;AAC1B,MAAI5F,IAAE,CAAN;AAAA,MAAQ7F,IAAE,CAAV;AAAA,MAAYyI,CAAZ;AACA,WAAS;AACP,QAAIjD,KAAG,CAAP,EAAU,OAAOK,CAAP;AACV,QAAIL,KAAG,CAAP,EAAU,OAAO,CAAP;AACVxF,SAAG6F,IAAElB,KAAKC,KAAL,CAAW6G,IAAEjG,CAAb,CAAL;AACAiG,SAAGjG,CAAH;;AAEA,QAAIiG,KAAG,CAAP,EAAU,OAAOzL,CAAP,CANH,CAMa;AACpB,QAAIyL,KAAG,CAAP,EAAU,OAAO,CAAP;AACV5F,SAAG7F,IAAE2E,KAAKC,KAAL,CAAWY,IAAEiG,CAAb,CAAL;AACAjG,SAAGiG,CAAH;AACD;AACF;;AAED;AACA,SAAS0D,cAAT,CAAwB3J,CAAxB,EAA0BiG,CAA1B,EAA6B;AAC1B,SAAOyD,cAAc1J,CAAd,EAAgBiG,CAAhB,CAAP;AACF;;AAGD;AACA;AACA;AACO,SAASnE,KAAT,CAAe9B,CAAf,EAAiBC,CAAjB,EAAmB2J,CAAnB,EAAqBvJ,CAArB,EAAuB7F,CAAvB,EAA0B;AAC/B,MAAIsF,IAAE,CAAN;AACA,MAAIgG,IAAE3G,KAAKoK,GAAL,CAASvJ,EAAE1I,MAAX,EAAkB2I,EAAE3I,MAApB,CAAN;AACA,MAAI2M,KAAK3M,MAAL,IAAawO,CAAjB,EAAoB;AAClB7B,WAAK,IAAIjJ,KAAJ,CAAU8K,CAAV,CAAL;AACA5B,WAAK,IAAIlJ,KAAJ,CAAU8K,CAAV,CAAL;AACA3B,WAAK,IAAInJ,KAAJ,CAAU8K,CAAV,CAAL;AACA1B,WAAK,IAAIpJ,KAAJ,CAAU8K,CAAV,CAAL;AACAzB,WAAK,IAAIrJ,KAAJ,CAAU8K,CAAV,CAAL;AACD;AACD,SAAM,EAAE9F,EAAE,CAAF,IAAK,CAAP,KAAc,EAAEC,EAAE,CAAF,IAAK,CAAP,CAApB,EAA+B;AAAG;AAChCuJ,WAAOxJ,CAAP;AACAwJ,WAAOvJ,CAAP;AACAH;AACD;AACD0B,QAAMyC,IAAN,EAAWjE,CAAX;AACAwB,QAAMoI,CAAN,EAAQ3J,CAAR;AACAsB,WAAS2C,IAAT,EAAc,CAAd;AACA3C,WAAS4C,IAAT,EAAc,CAAd;AACA5C,WAAS6C,IAAT,EAAc,CAAd;AACA7C,WAAS8C,IAAT,EAAc,CAAd;AACA,WAAS;AACP,WAAM,EAAEJ,KAAK,CAAL,IAAQ,CAAV,CAAN,EAAoB;AAAG;AACrBuF,aAAOvF,IAAP;AACA,UAAI,EAAEC,KAAK,CAAL,IAAQ,CAAV,KAAgB,EAAEC,KAAK,CAAL,IAAQ,CAAV,CAApB,EAAkC;AAAE;AAClCqF,eAAOtF,IAAP;AACAsF,eAAOrF,IAAP;AACD,OAHD,MAGO;AACLzC,aAAKwC,IAAL,EAAUjE,CAAV,EAAeuJ,OAAOtF,IAAP;AACftC,aAAKuC,IAAL,EAAUnE,CAAV,EAAewJ,OAAOrF,IAAP;AAChB;AACF;;AAED,WAAO,EAAEyF,EAAE,CAAF,IAAK,CAAP,CAAP,EAAkB;AAAG;AACnBJ,aAAOI,CAAP;AACA,UAAI,EAAExF,KAAK,CAAL,IAAQ,CAAV,KAAgB,EAAEC,KAAK,CAAL,IAAQ,CAAV,CAApB,EAAkC;AAAE;AAClCmF,eAAOpF,IAAP;AACAoF,eAAOnF,IAAP;AACD,OAHD,MAGO;AACL3C,aAAK0C,IAAL,EAAUnE,CAAV,EAAeuJ,OAAOpF,IAAP;AACfxC,aAAKyC,IAAL,EAAUrE,CAAV,EAAewJ,OAAOnF,IAAP;AAChB;AACF;;AAED,QAAI,CAAC1C,QAAQiI,CAAR,EAAU3F,IAAV,CAAL,EAAsB;AAAE;AACtBrC,WAAKqC,IAAL,EAAU2F,CAAV;AACAhI,WAAKsC,IAAL,EAAUE,IAAV;AACAxC,WAAKuC,IAAL,EAAUE,IAAV;AACD,KAJD,MAIO;AAAiB;AACtBzC,WAAKgI,CAAL,EAAO3F,IAAP;AACArC,WAAKwC,IAAL,EAAUF,IAAV;AACAtC,WAAKyC,IAAL,EAAUF,IAAV;AACD;AACD,QAAIpC,UAAUkC,IAAV,EAAe,CAAf,CAAJ,EAAuB;AACrB,aAAOwF,SAASrF,IAAT,CAAP,EAAuB;AAAI;AACzB1C,aAAK0C,IAAL,EAAUnE,CAAV;AACA2B,aAAKyC,IAAL,EAAUrE,CAAV;AACD;AACDyI,eAASpE,IAAT,EAAc,CAAC,CAAf,EALqB,CAKD;AACpB7C,YAAMnB,CAAN,EAAQ+D,IAAR;AACA5C,YAAMhH,CAAN,EAAQ6J,IAAR;AACAwF,iBAAWD,CAAX,EAAa9J,CAAb;AACA;AACD;AACF;AACF;;AAGD;AACA,SAAS2J,QAAT,CAAkBzJ,CAAlB,EAAqB;AACnB,SAASA,EAAEA,EAAE1I,MAAF,GAAS,CAAX,KAAgBqL,MAAI,CAArB,GAAyB,CAAjC;AACD;;AAGD;AACA;AACA;AACA,SAASmH,YAAT,CAAsB9J,CAAtB,EAAwBC,CAAxB,EAA0B8J,KAA1B,EAAiC;AAC/B,MAAI1S,CAAJ;AAAA,MAAO2S,KAAGhK,EAAE1I,MAAZ;AAAA,MAAoB2S,KAAGhK,EAAE3I,MAAzB;AACAwO,MAAIkE,KAAGD,KAAJ,GAAWE,EAAZ,GAAmBD,KAAGD,KAAtB,GAA+BE,EAAjC;AACA,OAAK5S,IAAE4S,KAAG,CAAH,GAAKF,KAAZ,EAAmB1S,IAAE2S,EAAF,IAAQ3S,KAAG,CAA9B,EAAiCA,GAAjC,EACE,IAAI2I,EAAE3I,CAAF,IAAK,CAAT,EACE,OAAO,CAAP,CAL2B,CAKjB;AACd,OAAKA,IAAE2S,KAAG,CAAH,GAAKD,KAAZ,EAAmB1S,IAAE4S,EAArB,EAAyB5S,GAAzB,EACE,IAAI4I,EAAE5I,CAAF,IAAK,CAAT,EACE,OAAO,CAAP,CAR2B,CAQjB;AACd,OAAKA,IAAEyO,IAAE,CAAT,EAAYzO,KAAG0S,KAAf,EAAsB1S,GAAtB,EACE,IAAS2I,EAAE3I,IAAE0S,KAAJ,IAAW9J,EAAE5I,CAAF,CAApB,EAA0B,OAAO,CAAP,CAA1B,KACK,IAAI2I,EAAE3I,IAAE0S,KAAJ,IAAW9J,EAAE5I,CAAF,CAAf,EAAqB,OAAO,CAAP;AAC5B,SAAO,CAAP;AACD;;AAED;AACO,SAASsK,OAAT,CAAiB3B,CAAjB,EAAmBC,CAAnB,EAAsB;AAC3B,MAAI5I,CAAJ;AACA,MAAIyO,IAAG9F,EAAE1I,MAAF,GAAS2I,EAAE3I,MAAZ,GAAsB0I,EAAE1I,MAAxB,GAAiC2I,EAAE3I,MAAzC;;AAEA,OAAKD,IAAE2I,EAAE1I,MAAT,EAAgBD,IAAE4I,EAAE3I,MAApB,EAA2BD,GAA3B,EACE,IAAI4I,EAAE5I,CAAF,CAAJ,EACE,OAAO,CAAP,CANuB,CAMZ;;AAEf,OAAKA,IAAE4I,EAAE3I,MAAT,EAAgBD,IAAE2I,EAAE1I,MAApB,EAA2BD,GAA3B,EACE,IAAI2I,EAAE3I,CAAF,CAAJ,EACE,OAAO,CAAP,CAVuB,CAUZ;;AAEf,OAAKA,IAAEyO,IAAE,CAAT,EAAWzO,KAAG,CAAd,EAAgBA,GAAhB,EACE,IAAI2I,EAAE3I,CAAF,IAAK4I,EAAE5I,CAAF,CAAT,EACE,OAAO,CAAP,CADF,KAEK,IAAI2I,EAAE3I,CAAF,IAAK4I,EAAE5I,CAAF,CAAT,EACH,OAAO,CAAP;AACJ,SAAO,CAAP;AACD;;AAED;AACA;AACA;AACA;AACA;AACO,SAAS2K,OAAT,CAAiBhC,CAAjB,EAAmBC,CAAnB,EAAqBF,CAArB,EAAuBoI,CAAvB,EAA0B;AAC/B,MAAI6B,EAAJ,EAAQC,EAAR;AACA,MAAI5S,CAAJ,EAAM+I,CAAN,EAAQ8J,EAAR,EAAWC,EAAX,EAAc7J,CAAd,EAAgBD,CAAhB,EAAkB7F,CAAlB;AACAgH,QAAM2G,CAAN,EAAQnI,CAAR;AACA,OAAKiK,KAAGhK,EAAE3I,MAAV,EAAiB2I,EAAEgK,KAAG,CAAL,KAAS,CAA1B,EAA4BA,IAA5B,CAAiC,CAJF,CAII;;AAEnC;AACAzP,MAAEyF,EAAEgK,KAAG,CAAL,CAAF;AACA,OAAK5J,IAAE,CAAP,EAAU7F,CAAV,EAAa6F,GAAb,EACE7F,MAAI,CAAJ;AACF6F,MAAEsC,MAAItC,CAAN,CAV+B,CAUrB;AACVwJ,aAAW5J,CAAX,EAAaI,CAAb,EAX+B,CAWb;AAClBwJ,aAAW1B,CAAX,EAAa9H,CAAb;;AAEA;AACA,OAAK2J,KAAG7B,EAAE7Q,MAAV,EAAiB6Q,EAAE6B,KAAG,CAAL,KAAS,CAAT,IAAcA,KAAGC,EAAlC,EAAqCD,IAArC,CAA0C,CAfX,CAea;;AAE5CzI,WAASxB,CAAT,EAAW,CAAX,EAjB+B,CAiBK;AACpC,SAAO,CAAC+J,aAAa7J,CAAb,EAAekI,CAAf,EAAiB6B,KAAGC,EAApB,CAAR,EAAiC;AAAG;AAClCG,cAAUjC,CAAV,EAAYlI,CAAZ,EAAc+J,KAAGC,EAAjB,EAD+B,CACG;AAClClK,MAAEiK,KAAGC,EAAL,IAF+B,CAEG;AACnC,GArB8B,CAqBK;;AAEpC,OAAK5S,IAAE2S,KAAG,CAAV,EAAa3S,KAAG4S,EAAhB,EAAoB5S,GAApB,EAAyB;AACvB,QAAI8Q,EAAE9Q,CAAF,KAAM4I,EAAEgK,KAAG,CAAL,CAAV,EACElK,EAAE1I,IAAE4S,EAAJ,IAAQrH,IAAR,CADF,KAGE7C,EAAE1I,IAAE4S,EAAJ,IAAQ9K,KAAKC,KAAL,CAAW,CAAC+I,EAAE9Q,CAAF,IAAKwL,KAAL,GAAWsF,EAAE9Q,IAAE,CAAJ,CAAZ,IAAoB4I,EAAEgK,KAAG,CAAL,CAA/B,CAAR;;AAEF;AACA;AACA;AACA;AACA;AACA,aAAS;AACPE,WAAG,CAACF,KAAG,CAAH,GAAOhK,EAAEgK,KAAG,CAAL,CAAP,GAAiB,CAAlB,IAAqBlK,EAAE1I,IAAE4S,EAAJ,CAAxB;AACA3J,UAAE6J,MAAIxH,GAAN;AACAwH,WAAGA,KAAKvH,IAAR;AACAsH,WAAG5J,IAAEP,EAAE1I,IAAE4S,EAAJ,IAAQhK,EAAEgK,KAAG,CAAL,CAAb;AACA3J,UAAE4J,MAAIvH,GAAN;AACAuH,WAAGA,KAAKtH,IAAR;;AAEA,UAAItC,KAAG6H,EAAE9Q,CAAF,CAAH,GAAU6S,MAAI/B,EAAE9Q,IAAE,CAAJ,CAAJ,GAAa8S,MAAI9S,IAAE,CAAF,GAAM8Q,EAAE9Q,IAAE,CAAJ,CAAN,GAAe,CAAnB,CAAb,GAAqC6S,KAAG/B,EAAE9Q,IAAE,CAAJ,CAAlD,GAA2DiJ,IAAE6H,EAAE9Q,CAAF,CAAjE,EACE0I,EAAE1I,IAAE4S,EAAJ,IADF,KAGE;AACH;;AAEDI,kBAAclC,CAAd,EAAgBlI,CAAhB,EAAkB,CAACF,EAAE1I,IAAE4S,EAAJ,CAAnB,EAA2B5S,IAAE4S,EAA7B,EAzBuB,CAyBc;AACrC,QAAIR,SAAStB,CAAT,CAAJ,EAAiB;AACfmC,gBAAUnC,CAAV,EAAYlI,CAAZ,EAAc5I,IAAE4S,EAAhB,EADe,CACc;AAC7BlK,QAAE1I,IAAE4S,EAAJ;AACD;AACF;;AAEDpI,cAAY5B,CAAZ,EAAcI,CAAd,EAvD+B,CAuDZ;AACnBwB,cAAYsG,CAAZ,EAAc9H,CAAd,EAxD+B,CAwDZ;AACpB;;AAED;AACA,SAASmI,MAAT,CAAgBxI,CAAhB,EAAmB;AACjB,MAAI3I,CAAJ,EAAMyO,CAAN,EAAQxF,CAAR,EAAU9F,CAAV;AACAsL,MAAE9F,EAAE1I,MAAJ;AACAgJ,MAAE,CAAF;AACA,OAAKjJ,IAAE,CAAP,EAASA,IAAEyO,CAAX,EAAazO,GAAb,EAAkB;AAChBiJ,SAAGN,EAAE3I,CAAF,CAAH;AACAmD,QAAE,CAAF;AACA,QAAI8F,IAAE,CAAN,EAAS;AACP9F,UAAE,EAAE8F,KAAGqC,GAAL,CAAF;AACArC,WAAG9F,IAAEqI,KAAL;AACD;AACD7C,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,QAAE,CAACA,KAAGqC,GAAJ,IAASnI,CAAX;AACD;AACF;;AAED;AACA,SAAS8M,MAAT,CAAgBtH,CAAhB,EAAkBiG,CAAlB,EAAqB;AACnB,MAAI5O,CAAJ;AAAA,MAAMiJ,IAAE,CAAR;AACA,OAAKjJ,IAAE2I,EAAE1I,MAAF,GAAS,CAAhB,EAAmBD,KAAG,CAAtB,EAAyBA,GAAzB,EACEiJ,IAAE,CAACA,IAAEuC,KAAF,GAAQ7C,EAAE3I,CAAF,CAAT,IAAe4O,CAAjB;AACF,SAAO3F,CAAP;AACD;;AAED;AACA;AACA;AACA;AACA,SAAS0C,UAAT,CAAoBC,CAApB,EAAsBsH,IAAtB,EAA2BC,OAA3B,EAAoC;AAClC,MAAInT,CAAJ,EAAMyO,CAAN;AACAA,MAAE3G,KAAKQ,IAAL,CAAU4K,OAAK5H,GAAf,IAAoB,CAAtB;AACAmD,MAAE0E,UAAQ1E,CAAR,GAAY0E,OAAZ,GAAsB1E,CAAxB;AACA,MAAIC,OAAK,IAAI/K,KAAJ,CAAU8K,CAAV,CAAT;AACAvE,WAASwE,IAAT,EAAc9C,CAAd;AACA,SAAO8C,IAAP;AACD;;AAED;AACA;AACA;AACA;AACO,SAASrG,UAAT,CAAoBwG,CAApB,EAAsBuE,IAAtB,EAA2BD,OAA3B,EAAoC;AACzC,MAAIE,CAAJ,EAAOrT,CAAP,EAAU+I,CAAV,EAAaJ,CAAb,EAAgBC,CAAhB,EAAmB0K,EAAnB;AACA,MAAI7E,IAAEI,EAAE5O,MAAR;AACA,MAAImT,QAAM,CAAC,CAAX,EAAc;AAAE;AACdzK,QAAE,IAAIhF,KAAJ,CAAU,CAAV,CAAF;AACA,aAAS;AACPiF,UAAE,IAAIjF,KAAJ,CAAUgF,EAAE1I,MAAF,GAAS,CAAnB,CAAF;AACA,WAAKD,IAAE,CAAP,EAASA,IAAE2I,EAAE1I,MAAb,EAAoBD,GAApB,EACE4I,EAAE5I,IAAE,CAAJ,IAAO2I,EAAE3I,CAAF,CAAP;AACF4I,QAAE,CAAF,IAAKjI,SAASkO,CAAT,EAAW,EAAX,CAAL;AACAlG,UAAEC,CAAF;AACAyK,UAAExE,EAAE0E,OAAF,CAAU,GAAV,EAAc,CAAd,CAAF;AACA,UAAIF,IAAE,CAAN,EACE;AACFxE,UAAEA,EAAE2E,SAAF,CAAYH,IAAE,CAAd,CAAF;AACA,UAAIxE,EAAE5O,MAAF,IAAU,CAAd,EACE;AACH;AACD,QAAI0I,EAAE1I,MAAF,GAASkT,OAAb,EAAsB;AACpBvK,UAAE,IAAIjF,KAAJ,CAAUwP,OAAV,CAAF;AACAhJ,YAAMvB,CAAN,EAAQD,CAAR;AACA,aAAOC,CAAP;AACD;AACD,WAAOD,CAAP;AACD;;AAEDA,MAAEgD,WAAW,CAAX,EAAayH,OAAK3E,CAAlB,EAAoB,CAApB,CAAF;AACA,OAAKzO,IAAE,CAAP,EAASA,IAAEyO,CAAX,EAAazO,GAAb,EAAkB;AAChBqT,QAAE5H,UAAU8H,OAAV,CAAkB1E,EAAE2E,SAAF,CAAYxT,CAAZ,EAAcA,IAAE,CAAhB,CAAlB,EAAqC,CAArC,CAAF;AACA,QAAIoT,QAAM,EAAN,IAAYC,KAAG,EAAnB,EAAwB;AACtBA,WAAG,EAAH;AACF,QAAIA,KAAGD,IAAH,IAAWC,IAAE,CAAjB,EAAoB;AAAI;AACtB;AACD;AACDjC,aAASzI,CAAT,EAAWyK,IAAX;AACAjE,YAAQxG,CAAR,EAAU0K,CAAV;AACD;;AAED,OAAK5E,IAAE9F,EAAE1I,MAAT,EAAgBwO,IAAE,CAAF,IAAO,CAAC9F,EAAE8F,IAAE,CAAJ,CAAxB,EAA+BA,GAA/B,CAAmC,CAtCM,CAsCJ;AACrCA,MAAE0E,UAAQ1E,IAAE,CAAV,GAAc0E,OAAd,GAAwB1E,IAAE,CAA5B;AACA7F,MAAE,IAAIjF,KAAJ,CAAU8K,CAAV,CAAF;AACA6E,OAAG7E,IAAE9F,EAAE1I,MAAJ,GAAawO,CAAb,GAAiB9F,EAAE1I,MAAtB;AACA,OAAKD,IAAE,CAAP,EAASA,IAAEsT,EAAX,EAActT,GAAd,EACE4I,EAAE5I,CAAF,IAAK2I,EAAE3I,CAAF,CAAL;AACF,SAAMA,IAAEyO,CAAR,EAAUzO,GAAV,EACE4I,EAAE5I,CAAF,IAAK,CAAL;AACF,SAAO4I,CAAP;AACD;;AAED;AACA;AACO,SAAS8B,SAAT,CAAmB/B,CAAnB,EAAqBC,CAArB,EAAwB;AAC7B,MAAI5I,CAAJ;AACA,MAAI2I,EAAE,CAAF,KAAMC,CAAV,EACE,OAAO,CAAP;AACF,OAAK5I,IAAE,CAAP,EAASA,IAAE2I,EAAE1I,MAAb,EAAoBD,GAApB,EACE,IAAI2I,EAAE3I,CAAF,CAAJ,EACE,OAAO,CAAP;AACJ,SAAO,CAAP;AACD;;AAED;AACA;AACA,SAASkJ,MAAT,CAAgBP,CAAhB,EAAkBC,CAAlB,EAAqB;AACnB,MAAI5I,CAAJ;AACA,MAAIyO,IAAE9F,EAAE1I,MAAF,GAAS2I,EAAE3I,MAAX,GAAoB0I,EAAE1I,MAAtB,GAA+B2I,EAAE3I,MAAvC;AACA,OAAKD,IAAE,CAAP,EAASA,IAAEyO,CAAX,EAAazO,GAAb,EACE,IAAI2I,EAAE3I,CAAF,KAAM4I,EAAE5I,CAAF,CAAV,EACE,OAAO,CAAP;AACJ,MAAI2I,EAAE1I,MAAF,GAAS2I,EAAE3I,MAAf,EAAuB;AACrB,WAAMD,IAAE2I,EAAE1I,MAAV,EAAiBD,GAAjB,EACE,IAAI2I,EAAE3I,CAAF,CAAJ,EACE,OAAO,CAAP;AACL,GAJD,MAIO;AACL,WAAMA,IAAE4I,EAAE3I,MAAV,EAAiBD,GAAjB,EACE,IAAI4I,EAAE5I,CAAF,CAAJ,EACE,OAAO,CAAP;AACL;AACD,SAAO,CAAP;AACD;;AAED;AACO,SAASoK,MAAT,CAAgBzB,CAAhB,EAAmB;AACxB,MAAI3I,CAAJ;AACA,OAAKA,IAAE,CAAP,EAASA,IAAE2I,EAAE1I,MAAb,EAAoBD,GAApB,EACE,IAAI2I,EAAE3I,CAAF,CAAJ,EACE,OAAO,CAAP;AACJ,SAAO,CAAP;AACD;;AAED;AACA;AACO,SAASiD,UAAT,CAAoB0F,CAApB,EAAsByK,IAAtB,EAA4B;AACjC,MAAIpT,CAAJ;AAAA,MAAM4L,CAAN;AAAA,MAAQiD,IAAE,EAAV;;AAEA,MAAIzC,GAAGnM,MAAH,IAAW0I,EAAE1I,MAAjB,EACEmM,KAAG6C,IAAItG,CAAJ,CAAH,CADF,KAGEwB,MAAMiC,EAAN,EAASzD,CAAT;;AAEF,MAAIyK,QAAM,CAAC,CAAX,EAAc;AAAE;AACd,SAAKpT,IAAE2I,EAAE1I,MAAF,GAAS,CAAhB,EAAkBD,IAAE,CAApB,EAAsBA,GAAtB,EACE6O,KAAGlG,EAAE3I,CAAF,IAAK,GAAR;AACF6O,SAAGlG,EAAE,CAAF,CAAH;AACD,GAJD,MAKK;AAAE;AACL,WAAO,CAACyB,OAAOgC,EAAP,CAAR,EAAoB;AAClBR,UAAE6H,QAAQrH,EAAR,EAAWgH,IAAX,CAAF,CADkB,CACG;AACrBvE,UAAEpD,UAAU+H,SAAV,CAAoB5H,CAApB,EAAsBA,IAAE,CAAxB,IAA2BiD,CAA7B;AACD;AACF;AACD,MAAIA,EAAE5O,MAAF,IAAU,CAAd,EACE4O,IAAE,GAAF;AACF,SAAOA,CAAP;AACD;;AAED;AACA,SAASI,GAAT,CAAatG,CAAb,EAAgB;AACd,MAAI3I,CAAJ;AACA0O,SAAK,IAAI/K,KAAJ,CAAUgF,EAAE1I,MAAZ,CAAL;AACAkK,QAAMuE,IAAN,EAAW/F,CAAX;AACA,SAAO+F,IAAP;AACD;;AAED;AACO,SAASvE,KAAT,CAAexB,CAAf,EAAiBC,CAAjB,EAAoB;AACzB,MAAI5I,CAAJ;AACA,MAAIyO,IAAE9F,EAAE1I,MAAF,GAAS2I,EAAE3I,MAAX,GAAoB0I,EAAE1I,MAAtB,GAA+B2I,EAAE3I,MAAvC;AACA,OAAKD,IAAE,CAAP,EAASA,IAAEyO,CAAX,EAAazO,GAAb,EACE2I,EAAE3I,CAAF,IAAK4I,EAAE5I,CAAF,CAAL;AACF,OAAKA,IAAEyO,CAAP,EAASzO,IAAE2I,EAAE1I,MAAb,EAAoBD,GAApB,EACE2I,EAAE3I,CAAF,IAAK,CAAL;AACH;;AAED;AACO,SAASkK,QAAT,CAAkBvB,CAAlB,EAAoBiG,CAApB,EAAuB;AAC5B,MAAI5O,CAAJ,EAAMiJ,CAAN;AACA,OAAKA,IAAE2F,CAAF,EAAI5O,IAAE,CAAX,EAAaA,IAAE2I,EAAE1I,MAAjB,EAAwBD,GAAxB,EAA6B;AAC3B2I,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,UAAIqC,GAAJ;AACD;AACF;;AAED;AACA;AACA,SAAS6D,OAAT,CAAiBxG,CAAjB,EAAmBiG,CAAnB,EAAsB;AACpB,MAAI5O,CAAJ,EAAMyO,CAAN,EAAQxF,CAAR,EAAU9F,CAAV;AACAwF,IAAE,CAAF,KAAMiG,CAAN;AACAH,MAAE9F,EAAE1I,MAAJ;AACAgJ,MAAE,CAAF;AACA,OAAKjJ,IAAE,CAAP,EAASA,IAAEyO,CAAX,EAAazO,GAAb,EAAkB;AAChBiJ,SAAGN,EAAE3I,CAAF,CAAH;AACAmD,QAAE,CAAF;AACA,QAAI8F,IAAE,CAAN,EAAS;AACP9F,UAAE,EAAE8F,KAAGqC,GAAL,CAAF;AACArC,WAAG9F,IAAEqI,KAAL;AACD;AACD7C,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,QAAE,CAACA,KAAGqC,GAAJ,IAASnI,CAAX;AACA,QAAI,CAAC8F,CAAL,EAAQ,OATQ,CASA;AACjB;AACF;;AAED;AACO,SAASuB,WAAT,CAAqB7B,CAArB,EAAuBiG,CAAvB,EAA0B;AAC/B,MAAI5O,CAAJ;AACA,MAAIyO,IAAE3G,KAAKC,KAAL,CAAW6G,IAAEtD,GAAb,CAAN;AACA,MAAImD,CAAJ,EAAO;AACL,SAAKzO,IAAE,CAAP,EAASA,IAAE2I,EAAE1I,MAAF,GAASwO,CAApB,EAAsBzO,GAAtB,EAA2B;AACzB2I,MAAE3I,CAAF,IAAK2I,EAAE3I,IAAEyO,CAAJ,CAAL;AACF,WAAMzO,IAAE2I,EAAE1I,MAAV,EAAiBD,GAAjB,EACE2I,EAAE3I,CAAF,IAAK,CAAL;AACF4O,SAAGtD,GAAH;AACD;AACD,OAAKtL,IAAE,CAAP,EAASA,IAAE2I,EAAE1I,MAAF,GAAS,CAApB,EAAsBD,GAAtB,EAA2B;AACzB2I,MAAE3I,CAAF,IAAKuL,QAAS5C,EAAE3I,IAAE,CAAJ,KAASsL,MAAIsD,CAAd,GAAqBjG,EAAE3I,CAAF,KAAM4O,CAAnC,CAAL;AACD;AACDjG,IAAE3I,CAAF,MAAO4O,CAAP;AACD;;AAED;AACA,SAASuD,MAAT,CAAgBxJ,CAAhB,EAAmB;AACjB,MAAI3I,CAAJ;AACA,OAAKA,IAAE,CAAP,EAASA,IAAE2I,EAAE1I,MAAF,GAAS,CAApB,EAAsBD,GAAtB,EAA2B;AACzB2I,MAAE3I,CAAF,IAAKuL,QAAS5C,EAAE3I,IAAE,CAAJ,KAASsL,MAAI,CAAd,GAAqB3C,EAAE3I,CAAF,KAAM,CAAnC,CAAL;AACD;AACD2I,IAAE3I,CAAF,IAAM2I,EAAE3I,CAAF,KAAM,CAAP,GAAa2I,EAAE3I,CAAF,IAAQwL,SAAO,CAAjC,CALiB,CAKsB;AACxC;;AAED;AACA,SAASgH,UAAT,CAAoB7J,CAApB,EAAsBiG,CAAtB,EAAyB;AACvB,MAAI5O,CAAJ;AACA,MAAIyO,IAAE3G,KAAKC,KAAL,CAAW6G,IAAEtD,GAAb,CAAN;AACA,MAAImD,CAAJ,EAAO;AACL,SAAKzO,IAAE2I,EAAE1I,MAAT,EAAiBD,KAAGyO,CAApB,EAAuBzO,GAAvB,EAA4B;AAC1B2I,MAAE3I,CAAF,IAAK2I,EAAE3I,IAAEyO,CAAJ,CAAL;AACF,WAAMzO,KAAG,CAAT,EAAWA,GAAX,EACE2I,EAAE3I,CAAF,IAAK,CAAL;AACF4O,SAAGtD,GAAH;AACD;AACD,MAAI,CAACsD,CAAL,EACE;AACF,OAAK5O,IAAE2I,EAAE1I,MAAF,GAAS,CAAhB,EAAkBD,IAAE,CAApB,EAAsBA,GAAtB,EAA2B;AACzB2I,MAAE3I,CAAF,IAAKuL,QAAS5C,EAAE3I,CAAF,KAAM4O,CAAP,GAAajG,EAAE3I,IAAE,CAAJ,KAASsL,MAAIsD,CAAlC,CAAL;AACD;AACDjG,IAAE3I,CAAF,IAAKuL,OAAQ5C,EAAE3I,CAAF,KAAM4O,CAAnB;AACD;;AAED;AACA;AACA,SAASwC,QAAT,CAAkBzI,CAAlB,EAAoBiG,CAApB,EAAuB;AACrB,MAAI5O,CAAJ,EAAMyO,CAAN,EAAQxF,CAAR,EAAU9F,CAAV;AACA,MAAI,CAACyL,CAAL,EACE;AACFH,MAAE9F,EAAE1I,MAAJ;AACAgJ,MAAE,CAAF;AACA,OAAKjJ,IAAE,CAAP,EAASA,IAAEyO,CAAX,EAAazO,GAAb,EAAkB;AAChBiJ,SAAGN,EAAE3I,CAAF,IAAK4O,CAAR;AACAzL,QAAE,CAAF;AACA,QAAI8F,IAAE,CAAN,EAAS;AACP9F,UAAE,EAAE8F,KAAGqC,GAAL,CAAF;AACArC,WAAG9F,IAAEqI,KAAL;AACD;AACD7C,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,QAAE,CAACA,KAAGqC,GAAJ,IAASnI,CAAX;AACD;AACF;;AAED;AACA,SAASsQ,OAAT,CAAiB9K,CAAjB,EAAmBiG,CAAnB,EAAsB;AACpB,MAAI5O,CAAJ;AAAA,MAAM8Q,IAAE,CAAR;AAAA,MAAUjC,CAAV;AACA,OAAK7O,IAAE2I,EAAE1I,MAAF,GAAS,CAAhB,EAAkBD,KAAG,CAArB,EAAuBA,GAAvB,EAA4B;AAC1B6O,QAAEiC,IAAEtF,KAAF,GAAQ7C,EAAE3I,CAAF,CAAV;AACA2I,MAAE3I,CAAF,IAAK8H,KAAKC,KAAL,CAAW8G,IAAED,CAAb,CAAL;AACAkC,QAAEjC,IAAED,CAAJ;AACD;AACD,SAAOkC,CAAP;AACD;;AAED;AACA;AACA,SAASmB,QAAT,CAAkBtJ,CAAlB,EAAoBC,CAApB,EAAsBI,CAAtB,EAAwB7F,CAAxB,EAA2B;AACzB,MAAInD,CAAJ,EAAMiJ,CAAN,EAAQwF,CAAR,EAAU6E,EAAV;AACA7E,MAAE9F,EAAE1I,MAAF,GAAS2I,EAAE3I,MAAX,GAAoB0I,EAAE1I,MAAtB,GAA+B2I,EAAE3I,MAAnC;AACAqT,OAAG3K,EAAE1I,MAAL;AACA,OAAKgJ,IAAE,CAAF,EAAIjJ,IAAE,CAAX,EAAaA,IAAEyO,CAAf,EAAiBzO,GAAjB,EAAsB;AACpBiJ,SAAGD,IAAEL,EAAE3I,CAAF,CAAF,GAAOmD,IAAEyF,EAAE5I,CAAF,CAAZ;AACA2I,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,UAAIqC,GAAJ;AACD;AACD,OAAKtL,IAAEyO,CAAP,EAASzO,IAAEsT,EAAX,EAActT,GAAd,EAAmB;AACjBiJ,SAAGD,IAAEL,EAAE3I,CAAF,CAAL;AACA2I,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,UAAIqC,GAAJ;AACD;AACF;;AAED;AACA;AACA,SAAS0H,aAAT,CAAuBrK,CAAvB,EAAyBC,CAAzB,EAA2BzF,CAA3B,EAA6BuQ,EAA7B,EAAiC;AAC/B,MAAI1T,CAAJ,EAAMiJ,CAAN,EAAQwF,CAAR,EAAU6E,EAAV;AACA7E,MAAE9F,EAAE1I,MAAF,GAASyT,KAAG9K,EAAE3I,MAAd,GAAuB0I,EAAE1I,MAAzB,GAAkCyT,KAAG9K,EAAE3I,MAAzC;AACAqT,OAAG3K,EAAE1I,MAAL;AACA,OAAKgJ,IAAE,CAAF,EAAIjJ,IAAE0T,EAAX,EAAc1T,IAAEyO,CAAhB,EAAkBzO,GAAlB,EAAuB;AACrBiJ,SAAGN,EAAE3I,CAAF,IAAKmD,IAAEyF,EAAE5I,IAAE0T,EAAJ,CAAV;AACA/K,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,UAAIqC,GAAJ;AACD;AACD,OAAKtL,IAAEyO,CAAP,EAASxF,KAAKjJ,IAAEsT,EAAhB,EAAmBtT,GAAnB,EAAwB;AACtBiJ,SAAGN,EAAE3I,CAAF,CAAH;AACA2I,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,UAAIqC,GAAJ;AACD;AACF;;AAED;AACA;AACA,SAAS2H,SAAT,CAAmBtK,CAAnB,EAAqBC,CAArB,EAAuB8K,EAAvB,EAA2B;AACzB,MAAI1T,CAAJ,EAAMiJ,CAAN,EAAQwF,CAAR,EAAU6E,EAAV;AACA7E,MAAE9F,EAAE1I,MAAF,GAASyT,KAAG9K,EAAE3I,MAAd,GAAuB0I,EAAE1I,MAAzB,GAAkCyT,KAAG9K,EAAE3I,MAAzC;AACAqT,OAAG3K,EAAE1I,MAAL;AACA,OAAKgJ,IAAE,CAAF,EAAIjJ,IAAE0T,EAAX,EAAc1T,IAAEyO,CAAhB,EAAkBzO,GAAlB,EAAuB;AACrBiJ,SAAGN,EAAE3I,CAAF,IAAK4I,EAAE5I,IAAE0T,EAAJ,CAAR;AACA/K,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,UAAIqC,GAAJ;AACD;AACD,OAAKtL,IAAEyO,CAAP,EAASxF,KAAKjJ,IAAEsT,EAAhB,EAAmBtT,GAAnB,EAAwB;AACtBiJ,SAAGN,EAAE3I,CAAF,CAAH;AACA2I,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,UAAIqC,GAAJ;AACD;AACF;;AAED;AACA;AACA,SAASyH,SAAT,CAAmBpK,CAAnB,EAAqBC,CAArB,EAAuB8K,EAAvB,EAA2B;AACzB,MAAI1T,CAAJ,EAAMiJ,CAAN,EAAQwF,CAAR,EAAU6E,EAAV;AACA7E,MAAE9F,EAAE1I,MAAF,GAASyT,KAAG9K,EAAE3I,MAAd,GAAuB0I,EAAE1I,MAAzB,GAAkCyT,KAAG9K,EAAE3I,MAAzC;AACAqT,OAAG3K,EAAE1I,MAAL;AACA,OAAKgJ,IAAE,CAAF,EAAIjJ,IAAE0T,EAAX,EAAc1T,IAAEyO,CAAhB,EAAkBzO,GAAlB,EAAuB;AACrBiJ,SAAGN,EAAE3I,CAAF,IAAK4I,EAAE5I,IAAE0T,EAAJ,CAAR;AACA/K,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,UAAIqC,GAAJ;AACD;AACD,OAAKtL,IAAEyO,CAAP,EAASxF,KAAKjJ,IAAEsT,EAAhB,EAAmBtT,GAAnB,EAAwB;AACtBiJ,SAAGN,EAAE3I,CAAF,CAAH;AACA2I,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,UAAIqC,GAAJ;AACD;AACF;;AAED;AACA;AACA;AACO,SAASf,IAAT,CAAc5B,CAAd,EAAgBC,CAAhB,EAAmB;AACxB,MAAI5I,CAAJ,EAAMiJ,CAAN,EAAQwF,CAAR,EAAU6E,EAAV;AACA7E,MAAE9F,EAAE1I,MAAF,GAAS2I,EAAE3I,MAAX,GAAoB0I,EAAE1I,MAAtB,GAA+B2I,EAAE3I,MAAnC;AACA,OAAKgJ,IAAE,CAAF,EAAIjJ,IAAE,CAAX,EAAaA,IAAEyO,CAAf,EAAiBzO,GAAjB,EAAsB;AACpBiJ,SAAGN,EAAE3I,CAAF,IAAK4I,EAAE5I,CAAF,CAAR;AACA2I,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,UAAIqC,GAAJ;AACD;AACD,OAAKtL,IAAEyO,CAAP,EAASxF,KAAKjJ,IAAE2I,EAAE1I,MAAlB,EAAyBD,GAAzB,EAA8B;AAC5BiJ,SAAGN,EAAE3I,CAAF,CAAH;AACA2I,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,UAAIqC,GAAJ;AACD;AACF;;AAED;AACA;AACO,SAASjB,IAAT,CAAc1B,CAAd,EAAgBC,CAAhB,EAAmB;AACxB,MAAI5I,CAAJ,EAAMiJ,CAAN,EAAQwF,CAAR,EAAU6E,EAAV;AACA7E,MAAE9F,EAAE1I,MAAF,GAAS2I,EAAE3I,MAAX,GAAoB0I,EAAE1I,MAAtB,GAA+B2I,EAAE3I,MAAnC;AACA,OAAKgJ,IAAE,CAAF,EAAIjJ,IAAE,CAAX,EAAaA,IAAEyO,CAAf,EAAiBzO,GAAjB,EAAsB;AACpBiJ,SAAGN,EAAE3I,CAAF,IAAK4I,EAAE5I,CAAF,CAAR;AACA2I,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,UAAIqC,GAAJ;AACD;AACD,OAAKtL,IAAEyO,CAAP,EAASxF,KAAKjJ,IAAE2I,EAAE1I,MAAlB,EAAyBD,GAAzB,EAA8B;AAC5BiJ,SAAGN,EAAE3I,CAAF,CAAH;AACA2I,MAAE3I,CAAF,IAAKiJ,IAAIsC,IAAT;AACAtC,UAAIqC,GAAJ;AACD;AACF;;AAED;AACA,SAASgF,KAAT,CAAe3H,CAAf,EAAiBC,CAAjB,EAAoB;AAClB,MAAI5I,CAAJ;AACA,MAAI6L,GAAG5L,MAAH,IAAW,IAAE0I,EAAE1I,MAAnB,EACE4L,KAAG,IAAIlI,KAAJ,CAAU,IAAEgF,EAAE1I,MAAd,CAAH;AACFiK,WAAS2B,EAAT,EAAY,CAAZ;AACA,OAAK7L,IAAE,CAAP,EAASA,IAAE4I,EAAE3I,MAAb,EAAoBD,GAApB,EACE,IAAI4I,EAAE5I,CAAF,CAAJ,EACEgT,cAAcnH,EAAd,EAAiBlD,CAAjB,EAAmBC,EAAE5I,CAAF,CAAnB,EAAwBA,CAAxB,EAPc,CAOgB;AAClCmK,QAAMxB,CAAN,EAAQkD,EAAR;AACD;;AAED;AACA,SAASsE,IAAT,CAAcxH,CAAd,EAAgBiG,CAAhB,EAAmB;AACjB,MAAI1C,GAAGjM,MAAH,IAAW0I,EAAE1I,MAAjB,EACEiM,KAAG+C,IAAItG,CAAJ,CAAH,CADF,KAGEwB,MAAM+B,EAAN,EAASvD,CAAT;AACF,MAAIwD,GAAGlM,MAAH,IAAW0I,EAAE1I,MAAjB,EACEkM,KAAG8C,IAAItG,CAAJ,CAAH;AACFgC,UAAQuB,EAAR,EAAW0C,CAAX,EAAazC,EAAb,EAAgBxD,CAAhB,EAPiB,CAOI;AACtB;;AAED;AACA;AACA,SAASgI,QAAT,CAAkBhI,CAAlB,EAAoBC,CAApB,EAAsBgG,CAAtB,EAAyB;AACvB,MAAI5O,CAAJ;AACA,MAAI8L,GAAG7L,MAAH,IAAW,IAAE0I,EAAE1I,MAAnB,EACE6L,KAAG,IAAInI,KAAJ,CAAU,IAAEgF,EAAE1I,MAAd,CAAH;AACFiK,WAAS4B,EAAT,EAAY,CAAZ;AACA,OAAK9L,IAAE,CAAP,EAASA,IAAE4I,EAAE3I,MAAb,EAAoBD,GAApB,EACE,IAAI4I,EAAE5I,CAAF,CAAJ,EACEgT,cAAclH,EAAd,EAAiBnD,CAAjB,EAAmBC,EAAE5I,CAAF,CAAnB,EAAwBA,CAAxB,EAPmB,CAOW;AAClCmQ,OAAKrE,EAAL,EAAQ8C,CAAR;AACAzE,QAAMxB,CAAN,EAAQmD,EAAR;AACD;;AAED;AACA,SAASuD,UAAT,CAAoB1G,CAApB,EAAsBiG,CAAtB,EAAyB;AACvB,MAAI5O,CAAJ,EAAM+I,CAAN,EAAQsK,CAAR,EAAUpK,CAAV,EAAY0J,EAAZ,EAAegB,EAAf,EAAkBlF,CAAlB;AACA,OAAKkE,KAAGhK,EAAE1I,MAAV,EAAkB0S,KAAG,CAAH,IAAQ,CAAChK,EAAEgK,KAAG,CAAL,CAA3B,EAAoCA,IAApC,CAAyC,CAFlB,CAEqB;AAC5ClE,MAAEkE,KAAG/D,EAAE3O,MAAL,GAAc,IAAE0S,EAAhB,GAAqB,IAAE/D,EAAE3O,MAA3B,CAHuB,CAGY;AACnC,MAAI6L,GAAG7L,MAAH,IAAWwO,CAAf,EACE3C,KAAG,IAAInI,KAAJ,CAAU8K,CAAV,CAAH;AACFvE,WAAS4B,EAAT,EAAY,CAAZ;AACA,OAAK9L,IAAE,CAAP,EAASA,IAAE2S,EAAX,EAAc3S,GAAd,EAAmB;AACjBiJ,QAAE6C,GAAG,IAAE9L,CAAL,IAAQ2I,EAAE3I,CAAF,IAAK2I,EAAE3I,CAAF,CAAf;AACA8L,OAAG,IAAE9L,CAAL,IAAQiJ,IAAIsC,IAAZ;AACAtC,UAAIqC,GAAJ;AACA,SAAKvC,IAAE/I,IAAE,CAAT,EAAW+I,IAAE4J,EAAb,EAAgB5J,GAAhB,EAAqB;AACnBE,UAAE6C,GAAG9L,IAAE+I,CAAL,IAAQ,IAAEJ,EAAE3I,CAAF,CAAF,GAAO2I,EAAEI,CAAF,CAAf,GAAoBE,CAAtB;AACA6C,SAAG9L,IAAE+I,CAAL,IAASE,IAAIsC,IAAb;AACAtC,YAAIqC,GAAJ;AACD;AACDQ,OAAG9L,IAAE2S,EAAL,IAAS1J,CAAT;AACD;AACDkH,OAAKrE,EAAL,EAAQ8C,CAAR;AACAzE,QAAMxB,CAAN,EAAQmD,EAAR;AACD;;AAED;AACA,SAAS6D,IAAT,CAAchH,CAAd,EAAgB8F,CAAhB,EAAmB;AACjB,MAAIzO,CAAJ,EAAM4I,CAAN;AACA,OAAK5I,IAAE2I,EAAE1I,MAAT,EAAiBD,IAAE,CAAF,IAAO,CAAC2I,EAAE3I,IAAE,CAAJ,CAAzB,EAAiCA,GAAjC,CAAqC;AACrC4I,MAAE,IAAIjF,KAAJ,CAAU3D,IAAEyO,CAAZ,CAAF;AACAtE,QAAMvB,CAAN,EAAQD,CAAR;AACA,SAAOC,CAAP;AACD;;AAED;AACA;AACA,SAASwG,OAAT,CAAiBzG,CAAjB,EAAmBC,CAAnB,EAAqBgG,CAArB,EAAwB;AACtB,MAAIgF,EAAJ,EAAOC,EAAP,EAAUF,EAAV,EAAaG,EAAb;AACA,MAAGzH,GAAGpM,MAAH,IAAW2O,EAAE3O,MAAhB,EACEoM,KAAG4C,IAAIL,CAAJ,CAAH;;AAEF;AACA;AACA,MAAI,CAACA,EAAE,CAAF,IAAK,CAAN,KAAU,CAAd,EAAiB;AACfzE,UAAMkC,EAAN,EAAS1D,CAAT;AACAuB,aAASvB,CAAT,EAAW,CAAX;AACA,WAAM,CAAC+B,UAAU9B,CAAV,EAAY,CAAZ,CAAP,EAAuB;AACrB,UAAIA,EAAE,CAAF,IAAK,CAAT,EACE+H,SAAShI,CAAT,EAAW0D,EAAX,EAAcuC,CAAd;AACF6E,cAAQ7K,CAAR,EAAU,CAAV;AACAyG,iBAAWhD,EAAX,EAAcuC,CAAd;AACD;AACD;AACD;;AAED;AACA1E,WAASmC,EAAT,EAAY,CAAZ;AACA,OAAKsH,KAAG/E,EAAE3O,MAAV,EAAiB0T,KAAG,CAAH,IAAQ,CAAC/E,EAAE+E,KAAG,CAAL,CAA1B,EAAkCA,IAAlC,CAAuC;AACvCG,OAAGtI,QAAM6G,cAAcpC,OAAOrB,CAAP,EAASpD,KAAT,CAAd,EAA8BA,KAA9B,CAAT;AACAa,KAAGsH,EAAH,IAAO,CAAP;AACAhD,WAAShI,CAAT,EAAY0D,EAAZ,EAAeuC,CAAf,EAxBsB,CAwBD;;AAErB,MAAI3C,GAAGhM,MAAH,IAAW0I,EAAE1I,MAAjB,EACEgM,KAAGgD,IAAItG,CAAJ,CAAH,CADF,KAGEwB,MAAM8B,EAAN,EAAStD,CAAT;;AAEF,OAAKiL,KAAGhL,EAAE3I,MAAF,GAAS,CAAjB,EAAmB2T,KAAG,CAAH,GAAO,CAAChL,EAAEgL,EAAF,CAA3B,EAAkCA,IAAlC,CAAuC,CA/BjB,CA+BoB;AAC1C,MAAIhL,EAAEgL,EAAF,KAAO,CAAX,EAAc;AAAG;AACf1J,aAASvB,CAAT,EAAW,CAAX;AACA;AACD;AACD,OAAKkL,KAAG,KAAIvI,MAAI,CAAhB,EAAmBuI,MAAM,EAAEjL,EAAEgL,EAAF,IAAQC,EAAV,CAAzB,EAAwCA,OAAK,CAA7C,CAA+C,CApCzB,CAoC4B;AAClD,WAAS;AACP,QAAI,EAAEA,OAAK,CAAP,CAAJ,EAAe;AAAG;AAChBD;AACA,UAAIA,KAAG,CAAP,EAAU;AACRG,cAAMpL,CAAN,EAAQ+C,GAAR,EAAYkD,CAAZ,EAAckF,EAAd;AACA;AACD;AACDD,WAAG,KAAIvI,MAAI,CAAX;AACD;AACDyI,UAAMpL,CAAN,EAAQA,CAAR,EAAUiG,CAAV,EAAYkF,EAAZ;;AAEA,QAAID,KAAKjL,EAAEgL,EAAF,CAAT,EAAgB;AACdG,YAAMpL,CAAN,EAAQsD,EAAR,EAAW2C,CAAX,EAAakF,EAAb;AACH;AACF;;AAGD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,KAAT,CAAepL,CAAf,EAAiBC,CAAjB,EAAmBgG,CAAnB,EAAqBkF,EAArB,EAAyB;AACvB,MAAI9T,CAAJ,EAAM+I,CAAN,EAAQE,CAAR,EAAU+K,EAAV,EAAapI,CAAb,EAAeqI,EAAf;AACA,MAAIN,KAAG/E,EAAE3O,MAAT;AACA,MAAI2S,KAAGhK,EAAE3I,MAAT;;AAEA,MAAIsM,GAAGtM,MAAH,IAAW0T,EAAf,EACEpH,KAAG,IAAI5I,KAAJ,CAAUgQ,EAAV,CAAH;;AAEFzJ,WAASqC,EAAT,EAAY,CAAZ;;AAEA,SAAMoH,KAAG,CAAH,IAAQ/E,EAAE+E,KAAG,CAAL,KAAS,CAAvB,EAAyBA,IAAzB,CAA8B,CAVP,CAUS;AAChC,SAAMf,KAAG,CAAH,IAAQhK,EAAEgK,KAAG,CAAL,KAAS,CAAvB,EAAyBA,IAAzB,CAA8B,CAXP,CAWS;AAChCqB,OAAG1H,GAAGtM,MAAH,GAAU,CAAb,CAZuB,CAYP;;AAEhB;AACA,OAAKD,IAAE,CAAP,EAAUA,IAAE2T,EAAZ,EAAgB3T,GAAhB,EAAqB;AACnB4L,QAAEW,GAAG,CAAH,IAAM5D,EAAE3I,CAAF,IAAK4I,EAAE,CAAF,CAAb;AACAoL,SAAI,CAACpI,IAAIL,IAAL,IAAauI,EAAd,GAAoBvI,IAAvB,CAFmB,CAEW;AAC9BtC,QAAG2C,IAAEoI,KAAGpF,EAAE,CAAF,CAAN,IAAetD,GAAjB;AACAM,QAAEjD,EAAE3I,CAAF,CAAF;;AAEA;AACA+I,QAAE,CAAF;AACA,WAAMA,IAAE6J,KAAG,CAAX,GAAe;AAAE3J,WAAGsD,GAAGxD,CAAH,IAAMiL,KAAGpF,EAAE7F,CAAF,CAAT,GAAc6C,IAAEhD,EAAEG,CAAF,CAAnB,CAA2BwD,GAAGxD,IAAE,CAAL,IAAQE,IAAIsC,IAAZ,CAAoBtC,MAAIqC,GAAJ,CAAWvC;AAC1DE,WAAGsD,GAAGxD,CAAH,IAAMiL,KAAGpF,EAAE7F,CAAF,CAAT,GAAc6C,IAAEhD,EAAEG,CAAF,CAAnB,CAA2BwD,GAAGxD,IAAE,CAAL,IAAQE,IAAIsC,IAAZ,CAAoBtC,MAAIqC,GAAJ,CAAWvC;AAC1DE,WAAGsD,GAAGxD,CAAH,IAAMiL,KAAGpF,EAAE7F,CAAF,CAAT,GAAc6C,IAAEhD,EAAEG,CAAF,CAAnB,CAA2BwD,GAAGxD,IAAE,CAAL,IAAQE,IAAIsC,IAAZ,CAAoBtC,MAAIqC,GAAJ,CAAWvC;AAC1DE,WAAGsD,GAAGxD,CAAH,IAAMiL,KAAGpF,EAAE7F,CAAF,CAAT,GAAc6C,IAAEhD,EAAEG,CAAF,CAAnB,CAA2BwD,GAAGxD,IAAE,CAAL,IAAQE,IAAIsC,IAAZ,CAAoBtC,MAAIqC,GAAJ,CAAWvC;AAC1DE,WAAGsD,GAAGxD,CAAH,IAAMiL,KAAGpF,EAAE7F,CAAF,CAAT,GAAc6C,IAAEhD,EAAEG,CAAF,CAAnB,CAA2BwD,GAAGxD,IAAE,CAAL,IAAQE,IAAIsC,IAAZ,CAAoBtC,MAAIqC,GAAJ,CAAWvC;AAAM;AACjF,WAAMA,IAAE6J,EAAR,GAAe;AAAE3J,WAAGsD,GAAGxD,CAAH,IAAMiL,KAAGpF,EAAE7F,CAAF,CAAT,GAAc6C,IAAEhD,EAAEG,CAAF,CAAnB,CAA2BwD,GAAGxD,IAAE,CAAL,IAAQE,IAAIsC,IAAZ,CAAoBtC,MAAIqC,GAAJ,CAAWvC;AAAM;AACjF,WAAMA,IAAE4K,KAAG,CAAX,GAAe;AAAE1K,WAAGsD,GAAGxD,CAAH,IAAMiL,KAAGpF,EAAE7F,CAAF,CAAZ,CAA2BwD,GAAGxD,IAAE,CAAL,IAAQE,IAAIsC,IAAZ,CAAoBtC,MAAIqC,GAAJ,CAAWvC;AAC1DE,WAAGsD,GAAGxD,CAAH,IAAMiL,KAAGpF,EAAE7F,CAAF,CAAZ,CAA2BwD,GAAGxD,IAAE,CAAL,IAAQE,IAAIsC,IAAZ,CAAoBtC,MAAIqC,GAAJ,CAAWvC;AAC1DE,WAAGsD,GAAGxD,CAAH,IAAMiL,KAAGpF,EAAE7F,CAAF,CAAZ,CAA2BwD,GAAGxD,IAAE,CAAL,IAAQE,IAAIsC,IAAZ,CAAoBtC,MAAIqC,GAAJ,CAAWvC;AAC1DE,WAAGsD,GAAGxD,CAAH,IAAMiL,KAAGpF,EAAE7F,CAAF,CAAZ,CAA2BwD,GAAGxD,IAAE,CAAL,IAAQE,IAAIsC,IAAZ,CAAoBtC,MAAIqC,GAAJ,CAAWvC;AAC1DE,WAAGsD,GAAGxD,CAAH,IAAMiL,KAAGpF,EAAE7F,CAAF,CAAZ,CAA2BwD,GAAGxD,IAAE,CAAL,IAAQE,IAAIsC,IAAZ,CAAoBtC,MAAIqC,GAAJ,CAAWvC;AAAM;AACjF,WAAMA,IAAE4K,EAAR,GAAe;AAAE1K,WAAGsD,GAAGxD,CAAH,IAAMiL,KAAGpF,EAAE7F,CAAF,CAAZ,CAA2BwD,GAAGxD,IAAE,CAAL,IAAQE,IAAIsC,IAAZ,CAAoBtC,MAAIqC,GAAJ,CAAWvC;AAAM;AACjF,WAAMA,IAAEkL,EAAR,GAAe;AAAEhL,WAAGsD,GAAGxD,CAAH,CAAH,CAA2BwD,GAAGxD,IAAE,CAAL,IAAQE,IAAIsC,IAAZ,CAAoBtC,MAAIqC,GAAJ,CAAWvC;AAAM;AACjFwD,OAAGxD,IAAE,CAAL,IAAQE,IAAIsC,IAAZ;AACD;;AAED,MAAI,CAACjB,QAAQsE,CAAR,EAAUrC,EAAV,CAAL,EACEhC,KAAKgC,EAAL,EAAQqC,CAAR;AACFzE,QAAMxB,CAAN,EAAQ4D,EAAR;AACD,C;;;;;;ACl+CD;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,oBAAoB,6BAA6B;;AAEjD;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,eAAe,SAAS;AACxB;AACA,gBAAgB,SAAS;AACzB;AACA,gBAAgB,SAAS;;AAEzB,0BAA0B,wBAAwB;AAClD;AACA;AACA;AACA;;AAEA;AACA;AACA,2BAA2B,QAAQ;AACnC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,qBAAqB,eAAe,cAAc,UAAU;;AAE5D;AACA;AACA;AACA;AACA;AACA,8BAA8B;AAC9B;AACA;AACA;AACA,YAAY,qBAAqB,QAAQ;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,UAAU,iBAAiB;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,cAAc,KAAK;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,yBAAyB,eAAe,+BAA+B,UAAU;;AAEjF;AACA,sBAAsB,sCAAsC;;AAE5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,2BAA2B,OAAO,SAAS;AAC3C,yBAAyB,OAAO,QAAQ;AACxC,yBAAyB,OAAO,QAAQ;AACxC,yBAAyB,OAAO,QAAQ;AACxC,yBAAyB,OAAO,QAAQ;AACxC;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,uBAAuB,QAAQ;AAC/B,kBAAkB,QAAQ;AAC1B;AACA;AACA;;AAEA;AACA;AACA,oBAAoB,YAAY;AAChC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,QAAQ;AAC/B;AACA;AACA;AACA,mBAAmB,QAAQ;AAC3B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,wBAAwB,SAAS,QAAQ;AACzC;AACA;AACA;AACA;AACA,uBAAuB,YAAY;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,SAAS;AACzB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C;AAC1C,mBAAmB,oBAAoB,oBAAoB;AAC3D,YAAY,cAAc,cAAc;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB;AACnB;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC;AACpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,yBAAyB,YAAY;AACrC;AACA;AACA;AACA;AACA,yBAAyB,UAAU;AACnC,yBAAyB,2BAA2B;AACpD,4BAA4B,mBAAmB,gBAAgB;AAC/D,0BAA0B,eAAe,gBAAgB;;AAEzD;AACA;AACA;AACA;AACA;;AAEA,2CAA2C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB,gCAAgC;AAChC,kCAAkC;AAClC,iDAAiD;AACjD;AACA;AACA,sCAAsC;AACtC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,oBAAoB,cAAc;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,cAAc,UAAU;AACrD;AACA;AACA;AACA;AACA;;AAEA,yBAAyB;AACzB,6BAA6B,eAAe,gBAAgB;;AAE5D,wBAAwB;AACxB,+BAA+B,mBAAmB,gBAAgB;;AAElE;AACA;AACA;AACA;AACA;;AAEA;AACA,0BAA0B,6CAA6C;;AAEvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,WAAW,QAAQ,QAAQ;AACzC;AACA;AACA;;AAEA;AACA;AACA;AACA,mDAAmD;AACnD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA,wBAAwB,eAAe,gBAAgB,UAAU;;AAEjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,4BAA4B,6CAA6C;;AAEzE;AACA,6BAA6B,6CAA6C;;AAE1E;AACA,8BAA8B,iDAAiD;;AAE/E;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,cAAc;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC;AACrC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,cAAc,KAAK;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,0BAA0B,8BAA8B;AACxD,uBAAuB,oCAAoC;AAC3D,uBAAuB,oCAAoC;;AAE3D;AACA;AACA;AACA,gBAAgB,OAAO;AACvB;AACA;AACA,kBAAkB,YAAY;AAC9B;AACA;AACA;AACA;AACA,kBAAkB,SAAS;AAC3B;AACA;AACA;AACA;AACA;;AAEA;AACA,0BAA0B,YAAY;AACtC,uBAAuB,eAAe,4BAA4B,UAAU;;AAE5E;AACA,yBAAyB,YAAY;AACrC,sBAAsB,eAAe,2BAA2B,UAAU;;AAE1E;AACA,0BAA0B,YAAY;AACtC,uBAAuB,eAAe,4BAA4B,UAAU;;AAE5E;AACA,6BAA6B,aAAa;AAC1C,0BAA0B,eAAe,+BAA+B,UAAU;;AAElF;AACA;AACA;AACA,oBAAoB,YAAY;AAChC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,oCAAoC;AACpC;AACA;;AAEA;AACA;AACA;AACA,oCAAoC;AACpC;AACA;;AAEA;AACA;AACA;AACA;AACA,2BAA2B,UAAU,SAAS;AAC9C,yBAAyB,SAAS,QAAQ;AAC1C,wBAAwB,SAAS,QAAQ;AACzC,sBAAsB,SAAS,QAAQ;AACvC;AACA;AACA;;AAEA;AACA;AACA,oBAAoB,YAAY;AAChC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,qBAAqB,UAAU,KAAK;AACpC;AACA;;AAEA;AACA;AACA;AACA,oBAAoB,YAAY;AAChC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,0BAA0B,gCAAgC;;AAE1D;AACA,4BAA4B,oCAAoC;;AAEhE;AACA,2BAA2B,iCAAiC;;AAE5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,uBAAuB,eAAe,iBAAiB,UAAU;;AAEjE;AACA,4BAA4B,eAAe,iBAAiB,UAAU;;AAEtE;AACA,4BAA4B,eAAe,sBAAsB,UAAU;;AAE3E;AACA,yBAAyB,eAAe,kBAAkB,UAAU;;AAEpE;AACA,0BAA0B,eAAe,yBAAyB,UAAU;;AAE5E;AACA,6BAA6B,eAAe,yBAAyB,UAAU;;AAE/E;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,sBAAsB,UAAU;AAChC,4BAA4B,mBAAmB;AAC/C,0BAA0B,eAAe;;AAEzC;AACA;AACA;AACA;;AAEA;AACA,uBAAuB,kCAAkC;;AAEzD;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA,yBAAyB,OAAO;AAChC,8BAA8B,OAAO;AACrC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA,mCAAmC,SAAS;AAC5C;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,YAAY,eAAe,aAAa,gBAAgB,UAAU;AAClE;;AAEA,+BAA+B,UAAU;;AAEzC;AACA;AACA;AACA,4BAA4B,kBAAkB,WAAW;AACzD;AACA;AACA;AACA;AACA;AACA;;AAEA,qBAAqB;AACrB,gCAAgC,eAAe,gBAAgB;;AAE/D,qBAAqB;AACrB,kCAAkC,mBAAmB,gBAAgB;;AAErE;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,2BAA2B,SAAS,KAAK;AACzC,0BAA0B,cAAc,KAAK;AAC7C,iBAAiB;AACjB;AACA;AACA;AACA;AACA,wBAAwB,eAAe,eAAe,QAAQ;AAC9D,kCAAkC,OAAO,OAAO,QAAQ,QAAQ;AAChE;AACA;;AAEA;AACA,wBAAwB,OAAO,QAAQ;AACvC,uBAAuB,eAAe,KAAK;AAC3C;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,8BAA8B,WAAW,OAAO,OAAO;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,QAAQ;AAC1C;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C,iBAAiB,cAAc;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C,iBAAiB,cAAc;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC,yCAAyC;AACzC;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,kBAAkB,sBAAsB;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,sCAAsC,8BAA8B;AACpE;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,QAAQ;AAC5B;AACA;AACA;AACA;AACA;AACA,oBAAoB,cAAc;AAClC;AACA;AACA;AACA,mCAAmC;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,yBAAyB,4BAA4B;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,gBAAgB,eAAe;AAC/B;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,gBAAgB,SAAS;AACzB;AACA;AACA,gBAAgB,SAAS;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA,CAAC;;;;;;;;ACh1CD;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,UAAU;AAC7C;AACA;AACA,8BAA8B;AAC9B;AACA,qBAAqB,8BAA8B;AACnD;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG,eAAe;;AAElB;;AAEA;AACA;AACA;AACA;AACA,+BAA+B,sBAAsB;AACrD;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,kBAAkB;AAClB,mBAAmB;AACnB,sBAAsB;AACtB,mBAAmB;;AAEnB;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,mBAAmB,cAAc;AACjC;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA,GAAG;AACH;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,sDAAsD;;AAEtD;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,OAAO;AACP;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,qBAAqB,kEAAkE;;AAEvF;;AAEA,SAAS;AACT;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,GAAG;;AAEH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,qBAAqB,yCAAyC;;AAE9D;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;;;;;;;;ACjaA;AACA;;;AAGA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,KAAK,wCAAwC,EAAE,aAAa,sBAAsB;AAClF,KAAK,oDAAoD,EAAE,aAAa,0BAA0B;;;AAGlG;AACA;AACA;AACA;AACA,eAAe,SAAS;AACxB;AACA;AACA,kCAAkC;;;AAGlC;AACA;AACA;;AAEA;AACA,iBAAiB,iBAAiB;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,wBAAwB,aAAa;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,iBAAiB,SAAS;AAC1B;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,mCAAmC,SAAS;AAC5C;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,sBAAsB,SAAS;AAC/B;AACA;AACA,mBAAmB,qBAAqB,UAAU;;AAElD;AACA;AACA,oBAAoB,0BAA0B,gBAAgB,UAAU;;AAExE;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,oBAAoB,0BAA0B,UAAU;;AAExD;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,yBAAyB,kBAAkB;;AAE3C;AACA;AACA,kDAAkD,OAAO;;AAEzD;AACA;AACA,gBAAgB,YAAY;;AAE5B;AACA;AACA,kBAAkB,YAAY;;AAE9B;AACA;;;;;;;;ACxLA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;;AAEA;AACA;;;AAGA;;;;;;;;AC/BA;;;AAGA;;AAEA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;;;;;;;ACjDA;;AAEA;AACA;AACA;;;AAGA;AACA;AACA;;AAEA,iBAAiB,SAAS;AAC1B;AACA,mBAAmB,OAAO;AAC1B;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;;AAEA;;AAEA,mBAAmB,SAAS;AAC5B;AACA;;AAEA,sBAAsB;AACtB;;;AAGA;;;;;;;;ACxCA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;ACvCA;;AAEA;AACA,aAAa;AACb,cAAc;;AAEd;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,WAAW;AACX,WAAW;AACX,UAAU;AACV,UAAU;AACV;AACA,WAAW;AACX;AACA,YAAY;AACZ,YAAY;AACZ,YAAY;AACZ;AACA,eAAe;AACf,WAAW;AACX,WAAW;AACX,YAAY;AACZ,YAAY;AACZ,YAAY;AACZ,YAAY;AACZ,WAAW;AACX,SAAS;AACT;AACA,UAAU;AACV,WAAW;AACX,WAAW;AACX;;;AAGA,oBAAoB;;AAEpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,WAAW,GAAG;AACd;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,eAAe,GAAG;AAClB;AACA;AACA;AACA;;AAEA,wBAAwB;AACxB;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B,4BAA4B;AAC5B,6BAA6B;AAC7B;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA,mBAAmB;AACnB;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA,uBAAuB;AACvB;AACA,gCAAgC;AAChC;AACA,+BAA+B;AAC/B;AACA;AACA;AACA,mBAAmB;AACnB,qCAAqC;AACrC;AACA;AACA;AACA,oCAAoC;AACpC;AACA;AACA,+BAA+B;AAC/B;AACA;AACA;AACA,mBAAmB;AACnB;AACA,oCAAoC;AACpC;AACA;AACA;AACA;AACA,qBAAqB;AACrB,uCAAuC;AACvC;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA,+BAA+B;AAC/B;AACA;AACA;AACA,mBAAmB;AACnB,qCAAqC;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC;AACjC,kBAAkB;AAClB;AACA;AACA;AACA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,gBAAgB;AAChB;AACA;AACA,iCAAiC;AACjC;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,YAAY;AACZ;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACrUA;;;AAGA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;;AAGA,wBAAwB;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;;;AAGA,gBAAgB;AAChB,iBAAiB;AACjB,gBAAgB;AAChB,cAAc;AACd,iBAAiB;AACjB,iBAAiB;AACjB,gBAAgB;AAChB,mBAAmB;AACnB,gBAAgB;AAChB,mBAAmB;AACnB,iBAAiB;AACjB,qBAAqB;AACrB,uBAAuB;AACvB,uBAAuB;AACvB,sBAAsB;AACtB,qBAAqB;AACrB,sBAAsB;AACtB,wBAAwB;AACxB,yBAAyB;AACzB,yBAAyB;AACzB,wBAAwB;AACxB,2BAA2B;AAC3B,yBAAyB;AACzB,4BAA4B;AAC5B,0BAA0B;AAC1B,wBAAwB;AACxB,kBAAkB;AAClB,mBAAmB;AACnB,iBAAiB;AACjB,gBAAgB;AAChB,gBAAgB;AAChB,iBAAiB;;AAEjB;;;;AAIA;AACA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA,gBAAgB;AAChB,oBAAoB;AACpB,gBAAgB;AAChB,wBAAwB;AACxB,iBAAiB;AACjB,gBAAgB;AAChB,iBAAiB;AACjB,iBAAiB;AACjB;AACA,mBAAmB;;AAEnB;AACA,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,qBAAqB;;AAErB;AACA,gBAAgB;AAChB,gBAAgB;;AAEhB;AACA,kBAAkB;AAClB,kBAAkB;;AAElB;AACA,iBAAiB;;AAEjB;AACA,sBAAsB;AACtB,uBAAuB;AACvB,mBAAmB;AACnB,oBAAoB;;AAEpB;AACA,iBAAiB;AACjB,gBAAgB;AAChB,iBAAiB;AACjB,gBAAgB;AAChB,mBAAmB;;AAEnB,mCAAmC;AACnC,mCAAmC;;AAEnC;AACA;AACA;AACA;AACA,yCAAyC;AACzC,qBAAqB;AACrB,sBAAsB;AACtB,gBAAgB;AAChB,gBAAgB;AAChB,eAAe;AACf;;AAEA;AACA;;AAEA,6BAA6B,uBAAuB;AACpD;AACA;AACA,gBAAgB;AAChB,mBAAmB;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,6BAA6B,uBAAuB;AACpD;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA,6BAA6B,uBAAuB;AACpD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,cAAc,uBAAuB;AACrC,sBAAsB;;AAEtB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,oBAAoB;;AAEpB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,uBAAuB,uBAAuB;AAC9C,uBAAuB,uBAAuB;AAC9C,uBAAuB,uBAAuB;AAC9C,uBAAuB,uBAAuB;;AAE9C,uEAAuE,UAAU;;AAEjF;AACA;AACA,sBAAsB,uBAAuB;;AAE7C,uEAAuE,UAAU;;AAEjF;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,iBAAiB;AACzD,sCAAsC,qBAAqB;AAC3D;AACA;AACA;AACA;;AAEA;AACA;AACA,oBAAoB;AACpB,WAAW;AACX,UAAU;AACV,iBAAiB;AACjB,WAAW;AACX,WAAW;AACX,gBAAgB;AAChB,WAAW;AACX,WAAW;AACX;AACA,eAAe;AACf,mCAAmC;AACnC,aAAa;AACb,mCAAmC;AACnC,UAAU;AACV,UAAU;AACV,+BAA+B;AAC/B;;AAEA,QAAQ;;AAER;AACA;;;AAGA;AACA;AACA;AACA;;AAEA;AACA,4BAA4B,qBAAqB,EAAE;;;AAGnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,iBAAiB;AAC1C;AACA;AACA;AACA;AACA;AACA,gDAAgD;AAChD;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA,yBAAyB,iBAAiB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA,yBAAyB,iBAAiB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA,yBAAyB,iBAAiB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B;AAC3B;AACA,2BAA2B,iBAAiB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,aAAa;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,iBAAiB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,iBAAiB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA;AACA,kBAAkB,iBAAiB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,iBAAiB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,kBAAkB,iBAAiB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B;AAC3B;AACA,2BAA2B,iBAAiB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA,yBAAyB,iBAAiB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,iBAAiB;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB;AACA,yBAAyB,iBAAiB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA,yBAAyB,iBAAiB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,iBAAiB;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,aAAa;AACvC,0BAA0B,aAAa;AACvC,yBAAyB,iBAAiB;AAC1C,uCAAuC;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA,yBAAyB,iBAAiB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,iBAAiB;AAC5C;AACA;AACA;AACA;AACA;AACA,wDAAwD;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,cAAc;AACd;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe;AACf,kEAAkE;AAClE;AACA;AACA;;AAEA,oCAAoC,OAAO;AAC3C;AACA,2BAA2B,iBAAiB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,iBAAiB;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,iBAAiB;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,iBAAiB;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,+BAA+B,OAAO;;AAEtC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,cAAc;AACd;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,iBAAiB;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,gEAAgE;AAChE;AACA;AACA;;AAEA,gCAAgC,OAAO;AACvC;AACA,yBAAyB,iBAAiB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA;;AAEA,gDAAgD,OAAO;AACvD;AACA,2BAA2B,iBAAiB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,iBAAiB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,kEAAkE;AAClE;AACA;AACA;;AAEA,kCAAkC,OAAO;AACzC;AACA,yBAAyB,iBAAiB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA;;AAEA,gDAAgD,OAAO;AACvD;AACA,2BAA2B,iBAAiB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,iBAAiB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,iBAAiB;AACxC;AACA,gCAAgC;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,qBAAqB;AAC3D,8BAA8B,aAAa;AAC3C;AACA;AACA;AACA;AACA,aAAa;AACb,qCAAqC,kBAAkB;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,qBAAqB;AACvD;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA,wBAAwB,aAAa;AACrC;AACA;AACA;AACA;AACA,OAAO;AACP,+BAA+B,kBAAkB;AACjD;AACA;AACA,uBAAuB,iBAAiB;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,iBAAiB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD;AACtD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,iBAAiB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,6BAA6B,uBAAuB;AACpD;AACA,+BAA+B,uBAAuB;;AAEtD;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,6DAA6D,uBAAuB;AACpF;;AAEA;AACA;AACA;;AAEA;AACA;AACA,eAAe;AACf,wDAAwD;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACjgDA;;;AAGA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,yBAAyB;;AAEzB,cAAc;AACd,cAAc;AACd,uBAAuB;AACvB,eAAe;AACf,eAAe;AACf,eAAe;AACf,eAAe;AACf,eAAe;AACf,eAAe;AACf,WAAW;AACX,WAAW;AACX,UAAU;AACV,WAAW;AACX,WAAW;AACX,kBAAkB;AAClB;AACA,iBAAiB;AACjB,UAAU;AACV,2CAA2C,eAAe;AAC1D,0CAA0C,eAAe;AACzD;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,eAAe,gBAAgB;AAC/B;AACA;AACA,eAAe,aAAa;AAC5B;AACA;;AAEA;AACA;AACA,qBAAqB,UAAU;AAC/B,2BAA2B,OAAO;AAClC;AACA;AACA;AACA;AACA,kBAAkB;AAClB,sCAAsC,2BAA2B;AACjE,uCAAuC;AACvC,wCAAwC;AACxC;;;AAGA;AACA;AACA;AACA;;AAEA;AACA,aAAa;AACb;AACA,eAAe,WAAW;AAC1B,2BAA2B,OAAO;AAClC;AACA;AACA;AACA;;AAEA;AACA;AACA,eAAe,gBAAgB;AAC/B;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,cAAc;AACd;;AAEA;AACA;AACA,eAAe,eAAe;AAC9B;AACA;;AAEA;AACA,eAAe,aAAa;AAC5B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,wBAAwB;AACxB;;AAEA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA,GAAG,OAAO;AACV;AACA;AACA;AACA;;AAEA;AACA,WAAW;AACX,UAAU;AACV,YAAY;AACZ,qBAAqB;AACrB,cAAc;AACd,WAAW;AACX,WAAW;AACX,mBAAmB;AACnB,kBAAkB;;AAElB;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB;AACA;;AAEA;AACA;AACA;AACA,eAAe;AACf;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,kBAAkB;;AAElB;AACA;AACA;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,+CAA+C;AAC/C;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iCAAiC;AACjC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;;;;;;;ACpUA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACZA;;;AAGA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA,0BAA0B,cAAc;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,kBAAkB;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,SAAS;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,SAAS;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,SAAS;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,SAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,kBAAkB;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,OAAO;AAClC,aAAa;AACb,kCAAkC,OAAO;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,IAAI;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,iCAAiC;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,mBAAmB;AAC1C;AACA;AACA;AACA;AACA;AACA,2BAA2B,cAAc;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,wBAAwB;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,yBAAyB;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,yBAAyB;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,yBAAyB;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB,aAAa;AACb;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA,CAAC,I;;;;;;;AC7eD;;AAEA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;;AAEA;AACA;AACA,4CAA4C;;AAE5C;;;;;;;;;;ACpBA;;AAGApM,QAAQ+T,IAAR,CAAa,0BAAb;;AAEA,MAAMC,UAAUC,QAAQ;AACtB,UAAQA,KAAKC,IAAb;AACE,SAAK,WAAL;AAAoB,aAAO,yFAAApM,CAAqBmM,KAAKtU,KAA1B,CAAP;AACpB,SAAK,SAAL;AAAoB,aAAO,gFAAA8K,CAAYwJ,KAAKzL,CAAjB,EAAoByL,KAAKxL,CAAzB,EAA4BwL,KAAKvJ,CAAjC,CAAP;AACpB,SAAK,WAAL;AAAoB,aAAO,iFAAAvF,CAAa8O,KAAKtU,KAAlB,CAAP;AACpB,SAAK,aAAL;AAAoB,aAAO,mFAAA6G,CAAeyN,KAAKtU,KAApB,EAA2BsU,KAAKxN,QAAhC,EAA0CwN,KAAKvN,OAA/C,CAAP;AACpB,SAAK,aAAL;AAAoB,aAAO,mFAAAU,CAAe6M,KAAK7N,cAApB,EACe6N,KAAKxN,QADpB,EAC8BwN,KAAKvN,OADnC,CAAP;AAEpB;AACE,YAAM,IAAIyN,KAAJ,CAAW,iBAAgBF,KAAKC,IAAK,EAArC,CAAN;AARJ;AAUD,CAXD;;AAaAE,YAAY,UAASpJ,CAAT,EAAY;AACtB,MAAIA,EAAEiJ,IAAF,KAAW,EAAf,EAAmB;AACjBjU,YAAQ+T,IAAR,CAAa,mBAAb;AACD,GAFD,MAEO,IAAI,OAAO/I,EAAEiJ,IAAT,KAAkB,QAAtB,EAAgC;AACrCjU,YAAQ+T,IAAR,CAAa,4BAAb,EAA2C/I,EAAEiJ,IAA7C;AACD,GAFM,MAEA;AACL,UAAMI,SAASrJ,EAAEiJ,IAAF,CAAOI,MAAtB;AACA,UAAMxT,SAASmT,QAAQhJ,EAAEiJ,IAAV,CAAf;AACAK,gBAAY,EAAED,MAAF,EAAUxT,MAAV,EAAZ;AACD;AACF,CAVD;;AAYAyT,YAAY,OAAZ,E","file":"hash.worker.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// identity function for calling harmony imports with the correct context\n \t__webpack_require__.i = function(value) { return value; };\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 26);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap cc045fd835481af0af86","/*\nCryptoJS v3.1.2\ncode.google.com/p/crypto-js\n(c) 2009-2013 by Jeff Mott. All rights reserved.\ncode.google.com/p/crypto-js/wiki/License\n*/\n/**\r\n * CryptoJS core components.\r\n */\r\nvar CryptoJS = CryptoJS || (function (Math, undefined) {\r\n /**\r\n * CryptoJS namespace.\r\n */\r\n var C = {};\r\n\r\n /**\r\n * Library namespace.\r\n */\r\n var C_lib = C.lib = {};\r\n\r\n /**\r\n * Base object for prototypal inheritance.\r\n */\r\n var Base = C_lib.Base = (function () {\r\n function F() {}\r\n\r\n return {\r\n /**\r\n * Creates a new object that inherits from this object.\r\n *\r\n * @param {Object} overrides Properties to copy into the new object.\r\n *\r\n * @return {Object} The new object.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var MyType = CryptoJS.lib.Base.extend({\r\n * field: 'value',\r\n *\r\n * method: function () {\r\n * }\r\n * });\r\n */\r\n extend: function (overrides) {\r\n // Spawn\r\n F.prototype = this;\r\n var subtype = new F();\r\n\r\n // Augment\r\n if (overrides) {\r\n subtype.mixIn(overrides);\r\n }\r\n\r\n // Create default initializer\r\n if (!subtype.hasOwnProperty('init')) {\r\n subtype.init = function () {\r\n subtype.$super.init.apply(this, arguments);\r\n };\r\n }\r\n\r\n // Initializer's prototype is the subtype object\r\n subtype.init.prototype = subtype;\r\n\r\n // Reference supertype\r\n subtype.$super = this;\r\n\r\n return subtype;\r\n },\r\n\r\n /**\r\n * Extends this object and runs the init method.\r\n * Arguments to create() will be passed to init().\r\n *\r\n * @return {Object} The new object.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var instance = MyType.create();\r\n */\r\n create: function () {\r\n var instance = this.extend();\r\n instance.init.apply(instance, arguments);\r\n\r\n return instance;\r\n },\r\n\r\n /**\r\n * Initializes a newly created object.\r\n * Override this method to add some logic when your objects are created.\r\n *\r\n * @example\r\n *\r\n * var MyType = CryptoJS.lib.Base.extend({\r\n * init: function () {\r\n * // ...\r\n * }\r\n * });\r\n */\r\n init: function () {\r\n },\r\n\r\n /**\r\n * Copies properties into this object.\r\n *\r\n * @param {Object} properties The properties to mix in.\r\n *\r\n * @example\r\n *\r\n * MyType.mixIn({\r\n * field: 'value'\r\n * });\r\n */\r\n mixIn: function (properties) {\r\n for (var propertyName in properties) {\r\n if (properties.hasOwnProperty(propertyName)) {\r\n this[propertyName] = properties[propertyName];\r\n }\r\n }\r\n\r\n // IE won't copy toString using the loop above\r\n if (properties.hasOwnProperty('toString')) {\r\n this.toString = properties.toString;\r\n }\r\n },\r\n\r\n /**\r\n * Creates a copy of this object.\r\n *\r\n * @return {Object} The clone.\r\n *\r\n * @example\r\n *\r\n * var clone = instance.clone();\r\n */\r\n clone: function () {\r\n return this.init.prototype.extend(this);\r\n }\r\n };\r\n }());\r\n\r\n /**\r\n * An array of 32-bit words.\r\n *\r\n * @property {Array} words The array of 32-bit words.\r\n * @property {number} sigBytes The number of significant bytes in this word array.\r\n */\r\n var WordArray = C_lib.WordArray = Base.extend({\r\n /**\r\n * Initializes a newly created word array.\r\n *\r\n * @param {Array} words (Optional) An array of 32-bit words.\r\n * @param {number} sigBytes (Optional) The number of significant bytes in the words.\r\n *\r\n * @example\r\n *\r\n * var wordArray = CryptoJS.lib.WordArray.create();\r\n * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);\r\n * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);\r\n */\r\n init: function (words, sigBytes) {\r\n words = this.words = words || [];\r\n\r\n if (sigBytes != undefined) {\r\n this.sigBytes = sigBytes;\r\n } else {\r\n this.sigBytes = words.length * 4;\r\n }\r\n },\r\n\r\n /**\r\n * Converts this word array to a string.\r\n *\r\n * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex\r\n *\r\n * @return {string} The stringified word array.\r\n *\r\n * @example\r\n *\r\n * var string = wordArray + '';\r\n * var string = wordArray.toString();\r\n * var string = wordArray.toString(CryptoJS.enc.Utf8);\r\n */\r\n toString: function (encoder) {\r\n return (encoder || Hex).stringify(this);\r\n },\r\n\r\n /**\r\n * Concatenates a word array to this word array.\r\n *\r\n * @param {WordArray} wordArray The word array to append.\r\n *\r\n * @return {WordArray} This word array.\r\n *\r\n * @example\r\n *\r\n * wordArray1.concat(wordArray2);\r\n */\r\n concat: function (wordArray) {\r\n // Shortcuts\r\n var thisWords = this.words;\r\n var thatWords = wordArray.words;\r\n var thisSigBytes = this.sigBytes;\r\n var thatSigBytes = wordArray.sigBytes;\r\n\r\n // Clamp excess bits\r\n this.clamp();\r\n\r\n // Concat\r\n if (thisSigBytes % 4) {\r\n // Copy one byte at a time\r\n for (var i = 0; i < thatSigBytes; i++) {\r\n var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\r\n thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);\r\n }\r\n } else if (thatWords.length > 0xffff) {\r\n // Copy one word at a time\r\n for (var i = 0; i < thatSigBytes; i += 4) {\r\n thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];\r\n }\r\n } else {\r\n // Copy all words at once\r\n thisWords.push.apply(thisWords, thatWords);\r\n }\r\n this.sigBytes += thatSigBytes;\r\n\r\n // Chainable\r\n return this;\r\n },\r\n\r\n /**\r\n * Removes insignificant bits.\r\n *\r\n * @example\r\n *\r\n * wordArray.clamp();\r\n */\r\n clamp: function () {\r\n // Shortcuts\r\n var words = this.words;\r\n var sigBytes = this.sigBytes;\r\n\r\n // Clamp\r\n words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);\r\n words.length = Math.ceil(sigBytes / 4);\r\n },\r\n\r\n /**\r\n * Creates a copy of this word array.\r\n *\r\n * @return {WordArray} The clone.\r\n *\r\n * @example\r\n *\r\n * var clone = wordArray.clone();\r\n */\r\n clone: function () {\r\n var clone = Base.clone.call(this);\r\n clone.words = this.words.slice(0);\r\n\r\n return clone;\r\n },\r\n\r\n /**\r\n * Creates a word array filled with random bytes.\r\n *\r\n * @param {number} nBytes The number of random bytes to generate.\r\n *\r\n * @return {WordArray} The random word array.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var wordArray = CryptoJS.lib.WordArray.random(16);\r\n */\r\n random: function (nBytes) {\r\n var words = [];\r\n for (var i = 0; i < nBytes; i += 4) {\r\n words.push((Math.random() * 0x100000000) | 0);\r\n }\r\n\r\n return new WordArray.init(words, nBytes);\r\n }\r\n });\r\n\r\n /**\r\n * Encoder namespace.\r\n */\r\n var C_enc = C.enc = {};\r\n\r\n /**\r\n * Hex encoding strategy.\r\n */\r\n var Hex = C_enc.Hex = {\r\n /**\r\n * Converts a word array to a hex string.\r\n *\r\n * @param {WordArray} wordArray The word array.\r\n *\r\n * @return {string} The hex string.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var hexString = CryptoJS.enc.Hex.stringify(wordArray);\r\n */\r\n stringify: function (wordArray) {\r\n // Shortcuts\r\n var words = wordArray.words;\r\n var sigBytes = wordArray.sigBytes;\r\n\r\n // Convert\r\n var hexChars = [];\r\n for (var i = 0; i < sigBytes; i++) {\r\n var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\r\n hexChars.push((bite >>> 4).toString(16));\r\n hexChars.push((bite & 0x0f).toString(16));\r\n }\r\n\r\n return hexChars.join('');\r\n },\r\n\r\n /**\r\n * Converts a hex string to a word array.\r\n *\r\n * @param {string} hexStr The hex string.\r\n *\r\n * @return {WordArray} The word array.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var wordArray = CryptoJS.enc.Hex.parse(hexString);\r\n */\r\n parse: function (hexStr) {\r\n // Shortcut\r\n var hexStrLength = hexStr.length;\r\n\r\n // Convert\r\n var words = [];\r\n for (var i = 0; i < hexStrLength; i += 2) {\r\n words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);\r\n }\r\n\r\n return new WordArray.init(words, hexStrLength / 2);\r\n }\r\n };\r\n\r\n /**\r\n * Latin1 encoding strategy.\r\n */\r\n var Latin1 = C_enc.Latin1 = {\r\n /**\r\n * Converts a word array to a Latin1 string.\r\n *\r\n * @param {WordArray} wordArray The word array.\r\n *\r\n * @return {string} The Latin1 string.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);\r\n */\r\n stringify: function (wordArray) {\r\n // Shortcuts\r\n var words = wordArray.words;\r\n var sigBytes = wordArray.sigBytes;\r\n\r\n // Convert\r\n var latin1Chars = [];\r\n for (var i = 0; i < sigBytes; i++) {\r\n var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\r\n latin1Chars.push(String.fromCharCode(bite));\r\n }\r\n\r\n return latin1Chars.join('');\r\n },\r\n\r\n /**\r\n * Converts a Latin1 string to a word array.\r\n *\r\n * @param {string} latin1Str The Latin1 string.\r\n *\r\n * @return {WordArray} The word array.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var wordArray = CryptoJS.enc.Latin1.parse(latin1String);\r\n */\r\n parse: function (latin1Str) {\r\n // Shortcut\r\n var latin1StrLength = latin1Str.length;\r\n\r\n // Convert\r\n var words = [];\r\n for (var i = 0; i < latin1StrLength; i++) {\r\n words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);\r\n }\r\n\r\n return new WordArray.init(words, latin1StrLength);\r\n }\r\n };\r\n\r\n /**\r\n * UTF-8 encoding strategy.\r\n */\r\n var Utf8 = C_enc.Utf8 = {\r\n /**\r\n * Converts a word array to a UTF-8 string.\r\n *\r\n * @param {WordArray} wordArray The word array.\r\n *\r\n * @return {string} The UTF-8 string.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);\r\n */\r\n stringify: function (wordArray) {\r\n try {\r\n return decodeURIComponent(escape(Latin1.stringify(wordArray)));\r\n } catch (e) {\r\n throw new Error('Malformed UTF-8 data');\r\n }\r\n },\r\n\r\n /**\r\n * Converts a UTF-8 string to a word array.\r\n *\r\n * @param {string} utf8Str The UTF-8 string.\r\n *\r\n * @return {WordArray} The word array.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var wordArray = CryptoJS.enc.Utf8.parse(utf8String);\r\n */\r\n parse: function (utf8Str) {\r\n return Latin1.parse(unescape(encodeURIComponent(utf8Str)));\r\n }\r\n };\r\n\r\n /**\r\n * Abstract buffered block algorithm template.\r\n *\r\n * The property blockSize must be implemented in a concrete subtype.\r\n *\r\n * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0\r\n */\r\n var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({\r\n /**\r\n * Resets this block algorithm's data buffer to its initial state.\r\n *\r\n * @example\r\n *\r\n * bufferedBlockAlgorithm.reset();\r\n */\r\n reset: function () {\r\n // Initial values\r\n this._data = new WordArray.init();\r\n this._nDataBytes = 0;\r\n },\r\n\r\n /**\r\n * Adds new data to this block algorithm's buffer.\r\n *\r\n * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.\r\n *\r\n * @example\r\n *\r\n * bufferedBlockAlgorithm._append('data');\r\n * bufferedBlockAlgorithm._append(wordArray);\r\n */\r\n _append: function (data) {\r\n // Convert string to WordArray, else assume WordArray already\r\n if (typeof data == 'string') {\r\n data = Utf8.parse(data);\r\n }\r\n\r\n // Append\r\n this._data.concat(data);\r\n this._nDataBytes += data.sigBytes;\r\n },\r\n\r\n /**\r\n * Processes available data blocks.\r\n *\r\n * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.\r\n *\r\n * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.\r\n *\r\n * @return {WordArray} The processed data.\r\n *\r\n * @example\r\n *\r\n * var processedData = bufferedBlockAlgorithm._process();\r\n * var processedData = bufferedBlockAlgorithm._process(!!'flush');\r\n */\r\n _process: function (doFlush) {\r\n // Shortcuts\r\n var data = this._data;\r\n var dataWords = data.words;\r\n var dataSigBytes = data.sigBytes;\r\n var blockSize = this.blockSize;\r\n var blockSizeBytes = blockSize * 4;\r\n\r\n // Count blocks ready\r\n var nBlocksReady = dataSigBytes / blockSizeBytes;\r\n if (doFlush) {\r\n // Round up to include partial blocks\r\n nBlocksReady = Math.ceil(nBlocksReady);\r\n } else {\r\n // Round down to include only full blocks,\r\n // less the number of blocks that must remain in the buffer\r\n nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);\r\n }\r\n\r\n // Count words ready\r\n var nWordsReady = nBlocksReady * blockSize;\r\n\r\n // Count bytes ready\r\n var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);\r\n\r\n // Process blocks\r\n if (nWordsReady) {\r\n for (var offset = 0; offset < nWordsReady; offset += blockSize) {\r\n // Perform concrete-algorithm logic\r\n this._doProcessBlock(dataWords, offset);\r\n }\r\n\r\n // Remove processed words\r\n var processedWords = dataWords.splice(0, nWordsReady);\r\n data.sigBytes -= nBytesReady;\r\n }\r\n\r\n // Return processed words\r\n return new WordArray.init(processedWords, nBytesReady);\r\n },\r\n\r\n /**\r\n * Creates a copy of this object.\r\n *\r\n * @return {Object} The clone.\r\n *\r\n * @example\r\n *\r\n * var clone = bufferedBlockAlgorithm.clone();\r\n */\r\n clone: function () {\r\n var clone = Base.clone.call(this);\r\n clone._data = this._data.clone();\r\n\r\n return clone;\r\n },\r\n\r\n _minBufferSize: 0\r\n });\r\n\r\n /**\r\n * Abstract hasher template.\r\n *\r\n * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)\r\n */\r\n var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({\r\n /**\r\n * Configuration options.\r\n */\r\n cfg: Base.extend(),\r\n\r\n /**\r\n * Initializes a newly created hasher.\r\n *\r\n * @param {Object} cfg (Optional) The configuration options to use for this hash computation.\r\n *\r\n * @example\r\n *\r\n * var hasher = CryptoJS.algo.SHA256.create();\r\n */\r\n init: function (cfg) {\r\n // Apply config defaults\r\n this.cfg = this.cfg.extend(cfg);\r\n\r\n // Set initial values\r\n this.reset();\r\n },\r\n\r\n /**\r\n * Resets this hasher to its initial state.\r\n *\r\n * @example\r\n *\r\n * hasher.reset();\r\n */\r\n reset: function () {\r\n // Reset data buffer\r\n BufferedBlockAlgorithm.reset.call(this);\r\n\r\n // Perform concrete-hasher logic\r\n this._doReset();\r\n },\r\n\r\n /**\r\n * Updates this hasher with a message.\r\n *\r\n * @param {WordArray|string} messageUpdate The message to append.\r\n *\r\n * @return {Hasher} This hasher.\r\n *\r\n * @example\r\n *\r\n * hasher.update('message');\r\n * hasher.update(wordArray);\r\n */\r\n update: function (messageUpdate) {\r\n // Append\r\n this._append(messageUpdate);\r\n\r\n // Update the hash\r\n this._process();\r\n\r\n // Chainable\r\n return this;\r\n },\r\n\r\n /**\r\n * Finalizes the hash computation.\r\n * Note that the finalize operation is effectively a destructive, read-once operation.\r\n *\r\n * @param {WordArray|string} messageUpdate (Optional) A final message update.\r\n *\r\n * @return {WordArray} The hash.\r\n *\r\n * @example\r\n *\r\n * var hash = hasher.finalize();\r\n * var hash = hasher.finalize('message');\r\n * var hash = hasher.finalize(wordArray);\r\n */\r\n finalize: function (messageUpdate) {\r\n // Final message update\r\n if (messageUpdate) {\r\n this._append(messageUpdate);\r\n }\r\n\r\n // Perform concrete-hasher logic\r\n var hash = this._doFinalize();\r\n\r\n return hash;\r\n },\r\n\r\n blockSize: 512/32,\r\n\r\n /**\r\n * Creates a shortcut function to a hasher's object interface.\r\n *\r\n * @param {Hasher} hasher The hasher to create a helper for.\r\n *\r\n * @return {Function} The shortcut function.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);\r\n */\r\n _createHelper: function (hasher) {\r\n return function (message, cfg) {\r\n return new hasher.init(cfg).finalize(message);\r\n };\r\n },\r\n\r\n /**\r\n * Creates a shortcut function to the HMAC's object interface.\r\n *\r\n * @param {Hasher} hasher The hasher to use in this HMAC helper.\r\n *\r\n * @return {Function} The shortcut function.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);\r\n */\r\n _createHmacHelper: function (hasher) {\r\n return function (message, key) {\r\n return new C_algo.HMAC.init(hasher, key).finalize(message);\r\n };\r\n }\r\n });\r\n\r\n /**\r\n * Algorithm namespace.\r\n */\r\n var C_algo = C.algo = {};\r\n\r\n return C;\r\n}(Math));\r\n\r\nexports.CryptoJS = CryptoJS;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/@goodmind/node-cryptojs-aes/lib/core.js\n// module id = 0\n// module chunks = 0","'use strict';\n\n\nvar TYPED_OK = (typeof Uint8Array !== 'undefined') &&\n (typeof Uint16Array !== 'undefined') &&\n (typeof Int32Array !== 'undefined');\n\n\nexports.assign = function (obj /*from1, from2, from3, ...*/) {\n var sources = Array.prototype.slice.call(arguments, 1);\n while (sources.length) {\n var source = sources.shift();\n if (!source) { continue; }\n\n if (typeof source !== 'object') {\n throw new TypeError(source + 'must be non-object');\n }\n\n for (var p in source) {\n if (source.hasOwnProperty(p)) {\n obj[p] = source[p];\n }\n }\n }\n\n return obj;\n};\n\n\n// reduce buffer size, avoiding mem copy\nexports.shrinkBuf = function (buf, size) {\n if (buf.length === size) { return buf; }\n if (buf.subarray) { return buf.subarray(0, size); }\n buf.length = size;\n return buf;\n};\n\n\nvar fnTyped = {\n arraySet: function (dest, src, src_offs, len, dest_offs) {\n if (src.subarray && dest.subarray) {\n dest.set(src.subarray(src_offs, src_offs + len), dest_offs);\n return;\n }\n // Fallback to ordinary array\n for (var i = 0; i < len; i++) {\n dest[dest_offs + i] = src[src_offs + i];\n }\n },\n // Join array of chunks to single array.\n flattenChunks: function (chunks) {\n var i, l, len, pos, chunk, result;\n\n // calculate data length\n len = 0;\n for (i = 0, l = chunks.length; i < l; i++) {\n len += chunks[i].length;\n }\n\n // join chunks\n result = new Uint8Array(len);\n pos = 0;\n for (i = 0, l = chunks.length; i < l; i++) {\n chunk = chunks[i];\n result.set(chunk, pos);\n pos += chunk.length;\n }\n\n return result;\n }\n};\n\nvar fnUntyped = {\n arraySet: function (dest, src, src_offs, len, dest_offs) {\n for (var i = 0; i < len; i++) {\n dest[dest_offs + i] = src[src_offs + i];\n }\n },\n // Join array of chunks to single array.\n flattenChunks: function (chunks) {\n return [].concat.apply([], chunks);\n }\n};\n\n\n// Enable/Disable typed arrays use, for testing\n//\nexports.setTyped = function (on) {\n if (on) {\n exports.Buf8 = Uint8Array;\n exports.Buf16 = Uint16Array;\n exports.Buf32 = Int32Array;\n exports.assign(exports, fnTyped);\n } else {\n exports.Buf8 = Array;\n exports.Buf16 = Array;\n exports.Buf32 = Array;\n exports.assign(exports, fnUntyped);\n }\n};\n\nexports.setTyped(TYPED_OK);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/pako/lib/utils/common.js\n// module id = 1\n// module chunks = 0","import { BigInteger, SecureRandom } from 'jsbn'\r\nimport Rusha from 'rusha'\r\nimport * as CryptoJSlib from '@goodmind/node-cryptojs-aes'\r\nconst { CryptoJS } = CryptoJSlib\r\n\r\nimport { inflate } from 'pako/lib/inflate'\r\n\r\n// import Int from 'big-integer'\r\n\r\n// import BN from 'bn.js'\r\n\r\nimport { eGCD_, greater, divide_, str2bigInt, equalsInt,\r\n isZero, bigInt2str, copy_, copyInt_, rightShift_,\r\n sub_, add_, powMod, bpe, one } from './leemon'\r\n\r\n// import { bigInt2str } from 'BigInt'\r\n\r\n// const { BigInteger } = jsbn\r\n\r\nconst rushaInstance = new Rusha(1024 * 1024)\r\n\r\nexport function bigint(num) {\r\n return new BigInteger(num.toString(16), 16)\r\n}\r\n\r\nexport function bigStringInt(strNum) {\r\n return new BigInteger(strNum, 10)\r\n}\r\n\r\nexport function dHexDump(bytes) {\r\n const arr = []\r\n for (let i = 0; i < bytes.length; i++) {\r\n if (i && !(i % 2)) {\r\n if (!(i % 16)) {\r\n arr.push('\\n')\r\n } else if (!(i % 4)) {\r\n arr.push(' ')\r\n } else {\r\n arr.push(' ')\r\n }\r\n }\r\n arr.push((bytes[i] < 16 ? '0' : '') + bytes[i].toString(16))\r\n }\r\n\r\n console.log(arr.join(''))\r\n}\r\n\r\nexport function bytesToHex(bytes = []) {\r\n const arr = []\r\n for (let i = 0; i < bytes.length; i++) {\r\n arr.push((bytes[i] < 16 ? '0' : '') + (bytes[i] || 0).toString(16))\r\n }\r\n return arr.join('')\r\n}\r\n\r\nexport function bytesFromHex(hexString) {\r\n const len = hexString.length\r\n let start = 0\r\n const bytes = []\r\n\r\n if (hexString.length % 2) {\r\n bytes.push(parseInt(hexString.charAt(0), 16))\r\n start++\r\n }\r\n\r\n for (let i = start; i < len; i += 2) {\r\n bytes.push(parseInt(hexString.substr(i, 2), 16))\r\n }\r\n\r\n return bytes\r\n}\r\n\r\nexport function bytesToBase64(bytes) {\r\n let mod3\r\n let result = ''\r\n\r\n for (let nLen = bytes.length, nUint24 = 0, nIdx = 0; nIdx < nLen; nIdx++) {\r\n mod3 = nIdx % 3\r\n nUint24 |= bytes[nIdx] << (16 >>> mod3 & 24)\r\n if (mod3 === 2 || nLen - nIdx === 1) {\r\n result += String.fromCharCode(\r\n uint6ToBase64(nUint24 >>> 18 & 63),\r\n uint6ToBase64(nUint24 >>> 12 & 63),\r\n uint6ToBase64(nUint24 >>> 6 & 63),\r\n uint6ToBase64(nUint24 & 63)\r\n )\r\n nUint24 = 0\r\n }\r\n }\r\n\r\n return result.replace(/A(?=A$|$)/g, '=')\r\n}\r\n\r\nexport function uint6ToBase64(nUint6) {\r\n return nUint6 < 26\r\n ? nUint6 + 65\r\n : nUint6 < 52\r\n ? nUint6 + 71\r\n : nUint6 < 62\r\n ? nUint6 - 4\r\n : nUint6 === 62\r\n ? 43\r\n : nUint6 === 63\r\n ? 47\r\n : 65\r\n}\r\n\r\n// export function base64ToBlob(base64str, mimeType) {\r\n// const sliceSize = 1024\r\n// const byteCharacters = atob(base64str)\r\n// const bytesLength = byteCharacters.length\r\n// const slicesCount = Math.ceil(bytesLength / sliceSize)\r\n// const byteArrays = new Array(slicesCount)\r\n\r\n// for (let sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {\r\n// const begin = sliceIndex * sliceSize\r\n// const end = Math.min(begin + sliceSize, bytesLength)\r\n\r\n// const bytes = new Array(end - begin)\r\n// for (let offset = begin, i = 0; offset < end; ++i, ++offset) {\r\n// bytes[i] = byteCharacters[offset].charCodeAt(0)\r\n// }\r\n// byteArrays[sliceIndex] = new Uint8Array(bytes)\r\n// }\r\n\r\n// return blobConstruct(byteArrays, mimeType)\r\n// }\r\n\r\n// export function dataUrlToBlob(url) {\r\n// // var name = 'b64blob ' + url.length\r\n// // console.time(name)\r\n// const urlParts = url.split(',')\r\n// const base64str = urlParts[1]\r\n// const mimeType = urlParts[0].split(':')[1].split(';')[0]\r\n// const blob = base64ToBlob(base64str, mimeType)\r\n// // console.timeEnd(name)\r\n// return blob\r\n// }\r\n\r\n// export function blobConstruct(blobParts, mimeType) {\r\n// let blob\r\n// try {\r\n// blob = new Blob(blobParts, { type: mimeType })\r\n// } catch (e) {\r\n// const bb = new BlobBuilder\r\n// angular.forEach(blobParts, function(blobPart) {\r\n// bb.append(blobPart)\r\n// })\r\n// blob = bb.getBlob(mimeType)\r\n// }\r\n// return blob\r\n// }\r\n\r\nexport function bytesCmp(bytes1, bytes2) {\r\n const len = bytes1.length\r\n if (len !== bytes2.length) {\r\n return false\r\n }\r\n\r\n for (let i = 0; i < len; i++) {\r\n if (bytes1[i] !== bytes2[i])\r\n return false\r\n }\r\n return true\r\n}\r\n\r\nexport function bytesXor(bytes1, bytes2) {\r\n const len = bytes1.length\r\n const bytes = []\r\n\r\n for (let i = 0; i < len; ++i) {\r\n bytes[i] = bytes1[i] ^ bytes2[i]\r\n }\r\n\r\n return bytes\r\n}\r\n\r\nexport function bytesToWords(bytes) {\r\n if (bytes instanceof ArrayBuffer) {\r\n bytes = new Uint8Array(bytes)\r\n }\r\n const len = bytes.length\r\n const words = []\r\n let i\r\n for (i = 0; i < len; i++) {\r\n words[i >>> 2] |= bytes[i] << (24 - (i % 4) * 8)\r\n }\r\n\r\n return new CryptoJS.lib.WordArray.init(words, len)\r\n}\r\n\r\nexport function bytesFromWords(wordArray) {\r\n const words = wordArray.words\r\n const sigBytes = wordArray.sigBytes\r\n const bytes = []\r\n\r\n for (let i = 0; i < sigBytes; i++) {\r\n bytes.push((words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff)\r\n }\r\n\r\n return bytes\r\n}\r\n\r\nexport function bytesFromBigInt(bigInt, len) {\r\n let bytes = bigInt.toByteArray()\r\n\r\n if (len && bytes.length < len) {\r\n const padding = []\r\n for (let i = 0, needPadding = len - bytes.length; i < needPadding; i++) {\r\n padding[i] = 0\r\n }\r\n if (bytes instanceof ArrayBuffer) {\r\n bytes = bufferConcat(padding, bytes)\r\n } else {\r\n bytes = padding.concat(bytes)\r\n }\r\n } else {\r\n while (!bytes[0] && (!len || bytes.length > len)) {\r\n bytes = bytes.slice(1)\r\n }\r\n }\r\n\r\n return bytes\r\n}\r\n\r\nexport function bytesFromLeemonBigInt(bigInt, len) {\r\n const str = bigInt2str(bigInt, 16)\r\n return bytesFromHex(str)\r\n}\r\n\r\nexport function bytesToArrayBuffer(b) {\r\n return (new Uint8Array(b)).buffer\r\n}\r\n\r\nexport function convertToArrayBuffer(bytes) {\r\n // Be careful with converting subarrays!!\r\n if (bytes instanceof ArrayBuffer) {\r\n return bytes\r\n }\r\n if (bytes.buffer !== undefined &&\r\n bytes.buffer.byteLength == bytes.length * bytes.BYTES_PER_ELEMENT) {\r\n return bytes.buffer\r\n }\r\n return bytesToArrayBuffer(bytes)\r\n}\r\n\r\nexport function convertToUint8Array(bytes) {\r\n if (bytes.buffer !== undefined) {\r\n return bytes\r\n }\r\n return new Uint8Array(bytes)\r\n}\r\n\r\nexport function convertToByteArray(bytes) {\r\n if (Array.isArray(bytes)) {\r\n return bytes\r\n }\r\n bytes = convertToUint8Array(bytes)\r\n const newBytes = []\r\n for (let i = 0, len = bytes.length; i < len; i++) {\r\n newBytes.push(bytes[i])\r\n }\r\n return newBytes\r\n}\r\n\r\nexport function bytesFromArrayBuffer(buffer) {\r\n const byteView = new Uint8Array(buffer)\r\n const bytes = Array.from( byteView )\r\n return bytes\r\n}\r\n\r\nexport function bufferConcat(buffer1, buffer2) {\r\n const l1 = buffer1.byteLength || buffer1.length\r\n const l2 = buffer2.byteLength || buffer2.length\r\n const tmp = new Uint8Array(l1 + l2)\r\n tmp.set(\r\n buffer1 instanceof ArrayBuffer\r\n ? new Uint8Array(buffer1)\r\n : buffer1,\r\n 0)\r\n tmp.set(\r\n buffer2 instanceof ArrayBuffer\r\n ? new Uint8Array(buffer2)\r\n : buffer2,\r\n l1)\r\n\r\n return tmp.buffer\r\n}\r\n\r\nexport function longToInts(sLong) {\r\n const divRem = bigStringInt(sLong).divideAndRemainder(bigint(0x100000000))\r\n\r\n return [divRem[0].intValue(), divRem[1].intValue()]\r\n}\r\n\r\nexport function longToBytes(sLong) {\r\n return bytesFromWords({ words: longToInts(sLong), sigBytes: 8 }).reverse()\r\n}\r\n\r\nexport function longFromInts(high, low) {\r\n return bigint(high)\r\n .shiftLeft(32)\r\n .add(bigint(low))\r\n .toString(10)\r\n}\r\n\r\nexport function intToUint(val) {\r\n val = parseInt(val)\r\n if (val < 0) {\r\n val = val + 4294967296\r\n }\r\n return val\r\n}\r\n\r\nexport function uintToInt(val) {\r\n if (val > 2147483647) {\r\n val = val - 4294967296\r\n }\r\n return val\r\n}\r\n\r\nexport function sha1HashSync(bytes) {\r\n // console.log(dT(), 'SHA-1 hash start', bytes.byteLength || bytes.length)\r\n const hashBytes = rushaInstance.rawDigest(bytes).buffer\r\n // console.log(dT(), 'SHA-1 hash finish')\r\n\r\n return hashBytes\r\n}\r\n\r\nexport function sha1BytesSync(bytes) {\r\n return bytesFromArrayBuffer(sha1HashSync(bytes))\r\n}\r\n\r\nexport function sha256HashSync(bytes) {\r\n // console.log(dT(), 'SHA-2 hash start', bytes.byteLength || bytes.length)\r\n const hashWords = CryptoJS.SHA256(bytesToWords(bytes))\r\n // console.log(dT(), 'SHA-2 hash finish')\r\n\r\n const hashBytes = bytesFromWords(hashWords)\r\n\r\n return hashBytes\r\n}\r\n\r\nexport function rsaEncrypt(publicKey, bytes) {\r\n bytes = addPadding(bytes, 255)\r\n\r\n // console.log('RSA encrypt start')\r\n const N = new BigInteger(publicKey.modulus, 16)\r\n const E = new BigInteger(publicKey.exponent, 16)\r\n const X = new BigInteger(bytes)\r\n const encryptedBigInt = X.modPowInt(E, N),\r\n encryptedBytes = bytesFromBigInt(encryptedBigInt, 256)\r\n // console.log('RSA encrypt finish')\r\n\r\n return encryptedBytes\r\n}\r\n\r\nexport function addPadding(bytes, blockSize, zeroes) {\r\n blockSize = blockSize || 16\r\n const len = bytes.byteLength || bytes.length\r\n const needPadding = blockSize - (len % blockSize)\r\n if (needPadding > 0 && needPadding < blockSize) {\r\n const padding = new Array(needPadding)\r\n if (zeroes) {\r\n for (let i = 0; i < needPadding; i++) {\r\n padding[i] = 0\r\n }\r\n } else {\r\n (new SecureRandom()).nextBytes(padding)\r\n }\r\n\r\n if (bytes instanceof ArrayBuffer) {\r\n bytes = bufferConcat(bytes, padding)\r\n } else {\r\n bytes = bytes.concat(padding)\r\n }\r\n }\r\n\r\n return bytes\r\n}\r\n\r\nexport function aesEncryptSync(bytes, keyBytes, ivBytes) {\r\n const len = bytes.byteLength || bytes.length\r\n\r\n // console.log(dT(), 'AES encrypt start', len/*, bytesToHex(keyBytes), bytesToHex(ivBytes)*/)\r\n bytes = addPadding(bytes)\r\n\r\n const encryptedWords = CryptoJS.AES.encrypt(bytesToWords(bytes), bytesToWords(keyBytes), {\r\n iv : bytesToWords(ivBytes),\r\n padding: CryptoJS.pad.NoPadding,\r\n mode : CryptoJS.mode.IGE\r\n }).ciphertext\r\n\r\n const encryptedBytes = bytesFromWords(encryptedWords)\r\n // console.log(dT(), 'AES encrypt finish')\r\n\r\n return encryptedBytes\r\n}\r\n\r\nexport function aesDecryptSync(encryptedBytes, keyBytes, ivBytes) {\r\n\r\n // console.log(dT(), 'AES decrypt start', encryptedBytes.length)\r\n const decryptedWords = CryptoJS.AES.decrypt({ ciphertext: bytesToWords(encryptedBytes) }, bytesToWords(keyBytes), {\r\n iv : bytesToWords(ivBytes),\r\n padding: CryptoJS.pad.NoPadding,\r\n mode : CryptoJS.mode.IGE\r\n })\r\n\r\n const bytes = bytesFromWords(decryptedWords)\r\n // console.log(dT(), 'AES decrypt finish')\r\n\r\n return bytes\r\n}\r\n\r\nexport function gzipUncompress(bytes) {\r\n // console.log('Gzip uncompress start')\r\n const result = inflate(bytes)\r\n // console.log('Gzip uncompress finish')\r\n return result\r\n}\r\n\r\nexport function nextRandomInt(maxValue) {\r\n return Math.floor(Math.random() * maxValue)\r\n}\r\n\r\n// const bytesToInt = bytes => Int(bytesToHex(bytes), 16)\r\n// const bytesFromInt = int => bytesFromHex(int.toString(16))\r\n\r\nexport function pqPrimeFactorization(pqBytes) {\r\n const what = new BigInteger(pqBytes)\r\n // const whatInt = bytesToInt(pqBytes)\r\n // const whatBn = new BN(bytesToHex(pqBytes), 16)\r\n let result = false\r\n // let intRes = []\r\n // const bnRes = []\r\n // console.log(dT(), 'PQ start', pqBytes, what.toString(16), what.bitLength())\r\n\r\n // try {\r\n // console.time('pq leemon')\r\n // const toHex = bytesToHex(pqBytes)\r\n result = pqPrimeLeemon(str2bigInt(what.toString(16), 16, Math.ceil(64 / bpe) + 1))\r\n // console.timeEnd('pq leemon')\r\n // } catch (e) {\r\n // console.error('Pq leemon Exception', e)\r\n // }\r\n\r\n /*if (result === false && what.bitLength() <= 64) {\r\n // console.time('PQ long')\r\n try {\r\n result = pqPrimeLong(goog.math.Long.fromString(what.toString(16), 16))\r\n } catch (e) {\r\n console.error('Pq long Exception', e)\r\n }\r\n // console.timeEnd('PQ long')\r\n }*/\r\n // console.log(result)\r\n\r\n // if (result === false) {\r\n // console.time('pq BigInt')\r\n // intRes = pqPrimeJsbn(what)\r\n // console.timeEnd('pq BigInt')\r\n\r\n // console.time('pq bn')\r\n // bnRes = pqPrimeBN(whatBn)\r\n // console.timeEnd('pq bn')\r\n // }\r\n // console.log(...result, ...bnRes)\r\n // console.log(dT(), 'PQ finish')\r\n\r\n return result\r\n //intRes//result//bnRes\r\n}\r\n\r\n/*export function pqPrimeBN(what) {\r\n let it = 0,\r\n g\r\n const nOne = new BN(1)\r\n for (let i = 0; i < 3; i++) {\r\n const q = (nextRandomInt(128) & 15) + 17\r\n let x = new BN(nextRandomInt(1000000000) + 1)\r\n let y = x.clone()\r\n const lim = 1 << (i + 18)\r\n\r\n for (let j = 1; j < lim; j++) {\r\n ++it\r\n let a = x.clone()\r\n let b = x.clone()\r\n let c = new BN(q)\r\n\r\n while (!b.isZero()) {\r\n if (!b.and(nOne).isZero()) {\r\n c = c.add(a)\r\n if (c.gt(what)) {\r\n c = c.sub(what)\r\n }\r\n }\r\n a = a.add(a)\r\n if (a.gt(what)) {\r\n a = a.sub(what)\r\n }\r\n b = b.shrn(1)\r\n }\r\n\r\n x = c.clone()\r\n const z = x.lt(y)\r\n ? y.sub(x)\r\n : x.sub(y)\r\n g = z.gcd(what)\r\n if (!g.eq(nOne)) {\r\n break\r\n }\r\n if ((j & (j - 1)) == 0) {\r\n y = x.clone()\r\n }\r\n }\r\n if (g.gt(nOne)) {\r\n break\r\n }\r\n }\r\n\r\n let f = what.div(g), P, Q\r\n\r\n if (g.gt(f)) {\r\n P = f\r\n Q = g\r\n } else {\r\n P = g\r\n Q = f\r\n }\r\n\r\n return [P.toArray(), Q.toArray(), it]\r\n}*/\r\n\r\nexport function pqPrimeJsbn(what) {\r\n let it = 0,\r\n g\r\n for (let i = 0; i < 3; i++) {\r\n const q = (nextRandomInt(128) & 15) + 17\r\n let x = bigint(nextRandomInt(1000000000) + 1)\r\n let y = x.clone()\r\n const lim = 1 << (i + 18)\r\n\r\n for (let j = 1; j < lim; j++) {\r\n ++it\r\n let a = x.clone()\r\n let b = x.clone()\r\n let c = bigint(q)\r\n\r\n while (!b.equals(BigInteger.ZERO)) {\r\n if (!b.and(BigInteger.ONE).equals(BigInteger.ZERO)) {\r\n c = c.add(a)\r\n if (c.compareTo(what) > 0) {\r\n c = c.subtract(what)\r\n }\r\n }\r\n a = a.add(a)\r\n if (a.compareTo(what) > 0) {\r\n a = a.subtract(what)\r\n }\r\n b = b.shiftRight(1)\r\n }\r\n\r\n x = c.clone()\r\n const z = x.compareTo(y) < 0 ? y.subtract(x) : x.subtract(y)\r\n g = z.gcd(what)\r\n if (!g.equals(BigInteger.ONE)) {\r\n break\r\n }\r\n if ((j & (j - 1)) == 0) {\r\n y = x.clone()\r\n }\r\n }\r\n if (g.compareTo(BigInteger.ONE) > 0) {\r\n break\r\n }\r\n }\r\n\r\n let f = what.divide(g), P, Q\r\n\r\n if (g.compareTo(f) > 0) {\r\n P = f\r\n Q = g\r\n } else {\r\n P = g\r\n Q = f\r\n }\r\n\r\n return [bytesFromBigInt(P), bytesFromBigInt(Q), it]\r\n}\r\n\r\n/*export function pqPrimeBigInteger(what) {\r\n let it = 0,\r\n g\r\n for (let i = 0; i < 3; i++) {\r\n const q = (nextRandomInt(128) & 15) + 17\r\n let x = Int(nextRandomInt(1000000000) + 1)\r\n let y = Int(x)\r\n const lim = 1 << (i + 18)\r\n\r\n for (let j = 1; j < lim; j++) {\r\n ++it\r\n let a = Int(x)\r\n let b = Int(x)\r\n let c = Int(q)\r\n\r\n while (!b.isZero()) {\r\n if (!b.and(Int.one).isZero()) {\r\n c = c.add(a)\r\n if (c.greater(what))\r\n c = c.subtract(what)\r\n }\r\n a = a.add(a)\r\n if (a.greater(what))\r\n a = a.subtract(what)\r\n b = b.shiftRight(1)\r\n }\r\n\r\n x = Int(c)\r\n const z = x.lesser(y)\r\n ? y.subtract(x)\r\n : x.subtract(y)\r\n g = Int.gcd(z, what)\r\n if (g.notEquals(Int.one))\r\n break\r\n if ((j & (j - 1)) == 0)\r\n y = Int(x)\r\n }\r\n if (g.greater(Int.one))\r\n break\r\n }\r\n\r\n const f = what.divide(g)\r\n let P, Q\r\n\r\n if (g.greater(f)) {\r\n P = f\r\n Q = g\r\n } else {\r\n P = g\r\n Q = f\r\n }\r\n\r\n return [bytesFromInt(P), bytesFromInt(Q), it]\r\n}*/\r\n\r\n/*export function gcdLong(a, b) {\r\n while (a.notEquals(goog.math.Long.ZERO) && b.notEquals(goog.math.Long.ZERO)) {\r\n while (b.and(goog.math.Long.ONE).equals(goog.math.Long.ZERO)) {\r\n b = b.shiftRight(1)\r\n }\r\n while (a.and(goog.math.Long.ONE).equals(goog.math.Long.ZERO)) {\r\n a = a.shiftRight(1)\r\n }\r\n if (a.compare(b) > 0) {\r\n a = a.subtract(b)\r\n } else {\r\n b = b.subtract(a)\r\n }\r\n }\r\n return b.equals(goog.math.Long.ZERO) ? a : b\r\n}\r\n\r\nexport function pqPrimeLong(what) {\r\n let it = 0,\r\n g\r\n for (let i = 0; i < 3; i++) {\r\n const q = goog.math.Long.fromInt((nextRandomInt(128) & 15) + 17)\r\n let x = goog.math.Long.fromInt(nextRandomInt(1000000000) + 1)\r\n let y = x\r\n const lim = 1 << (i + 18)\r\n\r\n for (let j = 1; j < lim; j++) {\r\n ++it\r\n let a = x\r\n let b = x\r\n let c = q\r\n\r\n while (b.notEquals(goog.math.Long.ZERO)) {\r\n if (b.and(goog.math.Long.ONE).notEquals(goog.math.Long.ZERO)) {\r\n c = c.add(a)\r\n if (c.compare(what) > 0) {\r\n c = c.subtract(what)\r\n }\r\n }\r\n a = a.add(a)\r\n if (a.compare(what) > 0) {\r\n a = a.subtract(what)\r\n }\r\n b = b.shiftRight(1)\r\n }\r\n\r\n x = c\r\n const z = x.compare(y) < 0 ? y.subtract(x) : x.subtract(y)\r\n g = gcdLong(z, what)\r\n if (g.notEquals(goog.math.Long.ONE)) {\r\n break\r\n }\r\n if ((j & (j - 1)) == 0) {\r\n y = x\r\n }\r\n }\r\n if (g.compare(goog.math.Long.ONE) > 0) {\r\n break\r\n }\r\n }\r\n\r\n let f = what.div(g), P, Q\r\n\r\n if (g.compare(f) > 0) {\r\n P = f\r\n Q = g\r\n } else {\r\n P = g\r\n Q = f\r\n }\r\n\r\n return [bytesFromHex(P.toString(16)), bytesFromHex(Q.toString(16)), it]\r\n}*/\r\n\r\n/*//is bigint x equal to integer y?\r\n//y must have less than bpe bits\r\nfunction equalsInt(x,y) {\r\n var i;\r\n if (x[0]!=y)\r\n return 0;\r\n for (i=1;i<x.length;i++)\r\n if (x[i])\r\n return 0;\r\n return 1;\r\n}*/\r\n\r\nexport function pqPrimeLeemon(what) {\r\n const minBits = 64\r\n const minLen = Math.ceil(minBits / bpe) + 1\r\n let it = 0\r\n let q, lim\r\n const a = new Array(minLen)\r\n const b = new Array(minLen)\r\n const c = new Array(minLen)\r\n const g = new Array(minLen)\r\n const z = new Array(minLen)\r\n const x = new Array(minLen)\r\n const y = new Array(minLen)\r\n\r\n for (let i = 0; i < 3; i++) {\r\n q = (nextRandomInt(128) & 15) + 17\r\n copyInt_(x, nextRandomInt(1000000000) + 1)\r\n copy_(y, x)\r\n lim = 1 << (i + 18)\r\n\r\n for (let j = 1; j < lim; j++) {\r\n ++it\r\n copy_(a, x)\r\n copy_(b, x)\r\n copyInt_(c, q)\r\n\r\n while (!isZero(b)) {\r\n if (b[0] & 1) {\r\n add_(c, a)\r\n if (greater(c, what)) {\r\n sub_(c, what)\r\n }\r\n }\r\n add_(a, a)\r\n if (greater(a, what)) {\r\n sub_(a, what)\r\n }\r\n rightShift_(b, 1)\r\n }\r\n\r\n copy_(x, c)\r\n if (greater(x, y)) {\r\n copy_(z, x)\r\n sub_(z, y)\r\n } else {\r\n copy_(z, y)\r\n sub_(z, x)\r\n }\r\n eGCD_(z, what, g, a, b)\r\n if (!equalsInt(g, 1)) {\r\n break\r\n }\r\n if ((j & (j - 1)) === 0) {\r\n copy_(y, x)\r\n }\r\n }\r\n if (greater(g, one)) {\r\n break\r\n }\r\n }\r\n\r\n divide_(what, g, x, y)\r\n\r\n const [P, Q] =\r\n greater(g, x)\r\n ? [x, g]\r\n : [g, x]\r\n\r\n // console.log(dT(), 'done', bigInt2str(what, 10), bigInt2str(P, 10), bigInt2str(Q, 10))\r\n\r\n return [bytesFromLeemonBigInt(P), bytesFromLeemonBigInt(Q), it]\r\n}\r\n\r\nexport function bytesModPow(x, y, m) {\r\n try {\r\n const xBigInt = str2bigInt(bytesToHex(x), 16)\r\n const yBigInt = str2bigInt(bytesToHex(y), 16)\r\n const mBigInt = str2bigInt(bytesToHex(m), 16)\r\n const resBigInt = powMod(xBigInt, yBigInt, mBigInt)\r\n\r\n return bytesFromHex(bigInt2str(resBigInt, 16))\r\n } catch (e) {\r\n console.error('mod pow error', e)\r\n }\r\n\r\n return bytesFromBigInt(new BigInteger(x).modPow(new BigInteger(y), new BigInteger(m)), 256)\r\n}\r\n\r\n\n\n\n// WEBPACK FOOTER //\n// ./bin.js","var CryptoJS = require('./lib/core').CryptoJS;\nrequire('./lib/enc-base64');\nrequire('./lib/md5');\nrequire('./lib/evpkdf');\nrequire('./lib/cipher-core');\nrequire('./lib/aes');\nrequire('./lib/sha256');\nvar JsonFormatter = require('./lib/jsonformatter').JsonFormatter;\n\nexports.CryptoJS = CryptoJS;\nexports.JsonFormatter = JsonFormatter;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/@goodmind/node-cryptojs-aes/cryptojs.js\n// module id = 3\n// module chunks = 0","var CryptoJS = require('./core').CryptoJS;\r\n\r\n/*\nCryptoJS v3.1.2\ncode.google.com/p/crypto-js\n(c) 2009-2013 by Jeff Mott. All rights reserved.\ncode.google.com/p/crypto-js/wiki/License\n*/\n(function () {\r\n // Shortcuts\r\n var C = CryptoJS;\r\n var C_lib = C.lib;\r\n var BlockCipher = C_lib.BlockCipher;\r\n var C_algo = C.algo;\r\n\r\n // Lookup tables\r\n var SBOX = [];\r\n var INV_SBOX = [];\r\n var SUB_MIX_0 = [];\r\n var SUB_MIX_1 = [];\r\n var SUB_MIX_2 = [];\r\n var SUB_MIX_3 = [];\r\n var INV_SUB_MIX_0 = [];\r\n var INV_SUB_MIX_1 = [];\r\n var INV_SUB_MIX_2 = [];\r\n var INV_SUB_MIX_3 = [];\r\n\r\n // Compute lookup tables\r\n (function () {\r\n // Compute double table\r\n var d = [];\r\n for (var i = 0; i < 256; i++) {\r\n if (i < 128) {\r\n d[i] = i << 1;\r\n } else {\r\n d[i] = (i << 1) ^ 0x11b;\r\n }\r\n }\r\n\r\n // Walk GF(2^8)\r\n var x = 0;\r\n var xi = 0;\r\n for (var i = 0; i < 256; i++) {\r\n // Compute sbox\r\n var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);\r\n sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;\r\n SBOX[x] = sx;\r\n INV_SBOX[sx] = x;\r\n\r\n // Compute multiplication\r\n var x2 = d[x];\r\n var x4 = d[x2];\r\n var x8 = d[x4];\r\n\r\n // Compute sub bytes, mix columns tables\r\n var t = (d[sx] * 0x101) ^ (sx * 0x1010100);\r\n SUB_MIX_0[x] = (t << 24) | (t >>> 8);\r\n SUB_MIX_1[x] = (t << 16) | (t >>> 16);\r\n SUB_MIX_2[x] = (t << 8) | (t >>> 24);\r\n SUB_MIX_3[x] = t;\r\n\r\n // Compute inv sub bytes, inv mix columns tables\r\n var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);\r\n INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);\r\n INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);\r\n INV_SUB_MIX_2[sx] = (t << 8) | (t >>> 24);\r\n INV_SUB_MIX_3[sx] = t;\r\n\r\n // Compute next counter\r\n if (!x) {\r\n x = xi = 1;\r\n } else {\r\n x = x2 ^ d[d[d[x8 ^ x2]]];\r\n xi ^= d[d[xi]];\r\n }\r\n }\r\n }());\r\n\r\n // Precomputed Rcon lookup\r\n var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];\r\n\r\n /**\r\n * AES block cipher algorithm.\r\n */\r\n var AES = C_algo.AES = BlockCipher.extend({\r\n _doReset: function () {\r\n // Shortcuts\r\n var key = this._key;\r\n var keyWords = key.words;\r\n var keySize = key.sigBytes / 4;\r\n\r\n // Compute number of rounds\r\n var nRounds = this._nRounds = keySize + 6\r\n\r\n // Compute number of key schedule rows\r\n var ksRows = (nRounds + 1) * 4;\r\n\r\n // Compute key schedule\r\n var keySchedule = this._keySchedule = [];\r\n for (var ksRow = 0; ksRow < ksRows; ksRow++) {\r\n if (ksRow < keySize) {\r\n keySchedule[ksRow] = keyWords[ksRow];\r\n } else {\r\n var t = keySchedule[ksRow - 1];\r\n\r\n if (!(ksRow % keySize)) {\r\n // Rot word\r\n t = (t << 8) | (t >>> 24);\r\n\r\n // Sub word\r\n t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];\r\n\r\n // Mix Rcon\r\n t ^= RCON[(ksRow / keySize) | 0] << 24;\r\n } else if (keySize > 6 && ksRow % keySize == 4) {\r\n // Sub word\r\n t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];\r\n }\r\n\r\n keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;\r\n }\r\n }\r\n\r\n // Compute inv key schedule\r\n var invKeySchedule = this._invKeySchedule = [];\r\n for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {\r\n var ksRow = ksRows - invKsRow;\r\n\r\n if (invKsRow % 4) {\r\n var t = keySchedule[ksRow];\r\n } else {\r\n var t = keySchedule[ksRow - 4];\r\n }\r\n\r\n if (invKsRow < 4 || ksRow <= 4) {\r\n invKeySchedule[invKsRow] = t;\r\n } else {\r\n invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^\r\n INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];\r\n }\r\n }\r\n },\r\n\r\n encryptBlock: function (M, offset) {\r\n this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);\r\n },\r\n\r\n decryptBlock: function (M, offset) {\r\n // Swap 2nd and 4th rows\r\n var t = M[offset + 1];\r\n M[offset + 1] = M[offset + 3];\r\n M[offset + 3] = t;\r\n\r\n this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);\r\n\r\n // Inv swap 2nd and 4th rows\r\n var t = M[offset + 1];\r\n M[offset + 1] = M[offset + 3];\r\n M[offset + 3] = t;\r\n },\r\n\r\n _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {\r\n // Shortcut\r\n var nRounds = this._nRounds;\r\n\r\n // Get input, add round key\r\n var s0 = M[offset] ^ keySchedule[0];\r\n var s1 = M[offset + 1] ^ keySchedule[1];\r\n var s2 = M[offset + 2] ^ keySchedule[2];\r\n var s3 = M[offset + 3] ^ keySchedule[3];\r\n\r\n // Key schedule row counter\r\n var ksRow = 4;\r\n\r\n // Rounds\r\n for (var round = 1; round < nRounds; round++) {\r\n // Shift rows, sub bytes, mix columns, add round key\r\n var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];\r\n var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];\r\n var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];\r\n var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];\r\n\r\n // Update state\r\n s0 = t0;\r\n s1 = t1;\r\n s2 = t2;\r\n s3 = t3;\r\n }\r\n\r\n // Shift rows, sub bytes, add round key\r\n var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];\r\n var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];\r\n var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];\r\n var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];\r\n\r\n // Set output\r\n M[offset] = t0;\r\n M[offset + 1] = t1;\r\n M[offset + 2] = t2;\r\n M[offset + 3] = t3;\r\n },\r\n\r\n keySize: 256/32\r\n });\r\n\r\n /**\r\n * Shortcut functions to the cipher's object interface.\r\n *\r\n * @example\r\n *\r\n * var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);\r\n * var plaintext = CryptoJS.AES.decrypt(ciphertext, key, cfg);\r\n */\r\n C.AES = BlockCipher._createHelper(AES);\r\n}());\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/@goodmind/node-cryptojs-aes/lib/aes.js\n// module id = 4\n// module chunks = 0","var CryptoJS = require('./core').CryptoJS;\r\n\r\n/*\nCryptoJS v3.1.2\ncode.google.com/p/crypto-js\n(c) 2009-2013 by Jeff Mott. All rights reserved.\ncode.google.com/p/crypto-js/wiki/License\n*/\n/**\r\n * Cipher core components.\r\n */\r\nCryptoJS.lib.Cipher || (function (undefined) {\r\n // Shortcuts\r\n var C = CryptoJS;\r\n var C_lib = C.lib;\r\n var Base = C_lib.Base;\r\n var WordArray = C_lib.WordArray;\r\n var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;\r\n var C_enc = C.enc;\r\n var Utf8 = C_enc.Utf8;\r\n var Base64 = C_enc.Base64;\r\n var C_algo = C.algo;\r\n var EvpKDF = C_algo.EvpKDF;\r\n\r\n /**\r\n * Abstract base cipher template.\r\n *\r\n * @property {number} keySize This cipher's key size. Default: 4 (128 bits)\r\n * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)\r\n * @property {number} _ENC_XFORM_MODE A constant representing encryption mode.\r\n * @property {number} _DEC_XFORM_MODE A constant representing decryption mode.\r\n */\r\n var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({\r\n /**\r\n * Configuration options.\r\n *\r\n * @property {WordArray} iv The IV to use for this operation.\r\n */\r\n cfg: Base.extend(),\r\n\r\n /**\r\n * Creates this cipher in encryption mode.\r\n *\r\n * @param {WordArray} key The key.\r\n * @param {Object} cfg (Optional) The configuration options to use for this operation.\r\n *\r\n * @return {Cipher} A cipher instance.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });\r\n */\r\n createEncryptor: function (key, cfg) {\r\n return this.create(this._ENC_XFORM_MODE, key, cfg);\r\n },\r\n\r\n /**\r\n * Creates this cipher in decryption mode.\r\n *\r\n * @param {WordArray} key The key.\r\n * @param {Object} cfg (Optional) The configuration options to use for this operation.\r\n *\r\n * @return {Cipher} A cipher instance.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });\r\n */\r\n createDecryptor: function (key, cfg) {\r\n return this.create(this._DEC_XFORM_MODE, key, cfg);\r\n },\r\n\r\n /**\r\n * Initializes a newly created cipher.\r\n *\r\n * @param {number} xformMode Either the encryption or decryption transormation mode constant.\r\n * @param {WordArray} key The key.\r\n * @param {Object} cfg (Optional) The configuration options to use for this operation.\r\n *\r\n * @example\r\n *\r\n * var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });\r\n */\r\n init: function (xformMode, key, cfg) {\r\n // Apply config defaults\r\n this.cfg = this.cfg.extend(cfg);\r\n\r\n // Store transform mode and key\r\n this._xformMode = xformMode;\r\n this._key = key;\r\n\r\n // Set initial values\r\n this.reset();\r\n },\r\n\r\n /**\r\n * Resets this cipher to its initial state.\r\n *\r\n * @example\r\n *\r\n * cipher.reset();\r\n */\r\n reset: function () {\r\n // Reset data buffer\r\n BufferedBlockAlgorithm.reset.call(this);\r\n\r\n // Perform concrete-cipher logic\r\n this._doReset();\r\n },\r\n\r\n /**\r\n * Adds data to be encrypted or decrypted.\r\n *\r\n * @param {WordArray|string} dataUpdate The data to encrypt or decrypt.\r\n *\r\n * @return {WordArray} The data after processing.\r\n *\r\n * @example\r\n *\r\n * var encrypted = cipher.process('data');\r\n * var encrypted = cipher.process(wordArray);\r\n */\r\n process: function (dataUpdate) {\r\n // Append\r\n this._append(dataUpdate);\r\n\r\n // Process available blocks\r\n return this._process();\r\n },\r\n\r\n /**\r\n * Finalizes the encryption or decryption process.\r\n * Note that the finalize operation is effectively a destructive, read-once operation.\r\n *\r\n * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.\r\n *\r\n * @return {WordArray} The data after final processing.\r\n *\r\n * @example\r\n *\r\n * var encrypted = cipher.finalize();\r\n * var encrypted = cipher.finalize('data');\r\n * var encrypted = cipher.finalize(wordArray);\r\n */\r\n finalize: function (dataUpdate) {\r\n // Final data update\r\n if (dataUpdate) {\r\n this._append(dataUpdate);\r\n }\r\n\r\n // Perform concrete-cipher logic\r\n var finalProcessedData = this._doFinalize();\r\n\r\n return finalProcessedData;\r\n },\r\n\r\n keySize: 128/32,\r\n\r\n ivSize: 128/32,\r\n\r\n _ENC_XFORM_MODE: 1,\r\n\r\n _DEC_XFORM_MODE: 2,\r\n\r\n /**\r\n * Creates shortcut functions to a cipher's object interface.\r\n *\r\n * @param {Cipher} cipher The cipher to create a helper for.\r\n *\r\n * @return {Object} An object with encrypt and decrypt shortcut functions.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);\r\n */\r\n _createHelper: (function () {\r\n function selectCipherStrategy(key) {\r\n if (typeof key == 'string') {\r\n return PasswordBasedCipher;\r\n } else {\r\n return SerializableCipher;\r\n }\r\n }\r\n\r\n return function (cipher) {\r\n return {\r\n encrypt: function (message, key, cfg) {\r\n return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);\r\n },\r\n\r\n decrypt: function (ciphertext, key, cfg) {\r\n return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);\r\n }\r\n };\r\n };\r\n }())\r\n });\r\n\r\n /**\r\n * Abstract base stream cipher template.\r\n *\r\n * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits)\r\n */\r\n var StreamCipher = C_lib.StreamCipher = Cipher.extend({\r\n _doFinalize: function () {\r\n // Process partial blocks\r\n var finalProcessedBlocks = this._process(!!'flush');\r\n\r\n return finalProcessedBlocks;\r\n },\r\n\r\n blockSize: 1\r\n });\r\n\r\n /**\r\n * Mode namespace.\r\n */\r\n var C_mode = C.mode = {};\r\n\r\n /**\r\n * Abstract base block cipher mode template.\r\n */\r\n var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({\r\n /**\r\n * Creates this mode for encryption.\r\n *\r\n * @param {Cipher} cipher A block cipher instance.\r\n * @param {Array} iv The IV words.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);\r\n */\r\n createEncryptor: function (cipher, iv) {\r\n return this.Encryptor.create(cipher, iv);\r\n },\r\n\r\n /**\r\n * Creates this mode for decryption.\r\n *\r\n * @param {Cipher} cipher A block cipher instance.\r\n * @param {Array} iv The IV words.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);\r\n */\r\n createDecryptor: function (cipher, iv) {\r\n return this.Decryptor.create(cipher, iv);\r\n },\r\n\r\n /**\r\n * Initializes a newly created mode.\r\n *\r\n * @param {Cipher} cipher A block cipher instance.\r\n * @param {Array} iv The IV words.\r\n *\r\n * @example\r\n *\r\n * var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);\r\n */\r\n init: function (cipher, iv) {\r\n this._cipher = cipher;\r\n this._iv = iv;\r\n }\r\n });\r\n\r\n /**\r\n * Cipher Block Chaining mode.\r\n */\r\n var CBC = C_mode.CBC = (function () {\r\n /**\r\n * Abstract base CBC mode.\r\n */\r\n var CBC = BlockCipherMode.extend();\r\n\r\n /**\r\n * CBC encryptor.\r\n */\r\n CBC.Encryptor = CBC.extend({\r\n /**\r\n * Processes the data block at offset.\r\n *\r\n * @param {Array} words The data words to operate on.\r\n * @param {number} offset The offset where the block starts.\r\n *\r\n * @example\r\n *\r\n * mode.processBlock(data.words, offset);\r\n */\r\n processBlock: function (words, offset) {\r\n // Shortcuts\r\n var cipher = this._cipher;\r\n var blockSize = cipher.blockSize;\r\n\r\n // XOR and encrypt\r\n xorBlock.call(this, words, offset, blockSize);\r\n cipher.encryptBlock(words, offset);\r\n\r\n // Remember this block to use with next block\r\n this._prevBlock = words.slice(offset, offset + blockSize);\r\n }\r\n });\r\n\r\n /**\r\n * CBC decryptor.\r\n */\r\n CBC.Decryptor = CBC.extend({\r\n /**\r\n * Processes the data block at offset.\r\n *\r\n * @param {Array} words The data words to operate on.\r\n * @param {number} offset The offset where the block starts.\r\n *\r\n * @example\r\n *\r\n * mode.processBlock(data.words, offset);\r\n */\r\n processBlock: function (words, offset) {\r\n // Shortcuts\r\n var cipher = this._cipher;\r\n var blockSize = cipher.blockSize;\r\n\r\n // Remember this block to use with next block\r\n var thisBlock = words.slice(offset, offset + blockSize);\r\n\r\n // Decrypt and XOR\r\n cipher.decryptBlock(words, offset);\r\n xorBlock.call(this, words, offset, blockSize);\r\n\r\n // This block becomes the previous block\r\n this._prevBlock = thisBlock;\r\n }\r\n });\r\n\r\n function xorBlock(words, offset, blockSize) {\r\n // Shortcut\r\n var iv = this._iv;\r\n\r\n // Choose mixing block\r\n if (iv) {\r\n var block = iv;\r\n\r\n // Remove IV for subsequent blocks\r\n this._iv = undefined;\r\n } else {\r\n var block = this._prevBlock;\r\n }\r\n\r\n // XOR blocks\r\n for (var i = 0; i < blockSize; i++) {\r\n words[offset + i] ^= block[i];\r\n }\r\n }\r\n\r\n return CBC;\r\n }());\r\n\r\n /**\r\n * Infinite Garble Extension mode.\r\n */\r\n var IGE = C_mode.IGE = (function () {\r\n /**\r\n * Abstract base IGE mode.\r\n */\r\n var IGE = BlockCipherMode.extend();\r\n\r\n /**\r\n * IGE encryptor.\r\n */\r\n IGE.Encryptor = IGE.extend({\r\n /**\r\n * Processes the data block at offset.\r\n *\r\n * @param {Array} words The data words to operate on.\r\n * @param {number} offset The offset where the block starts.\r\n *\r\n * @example\r\n *\r\n * mode.processBlock(data.words, offset);\r\n */\r\n processBlock: function (words, offset) {\r\n // Shortcuts\r\n var cipher = this._cipher;\r\n var blockSize = cipher.blockSize;\r\n\r\n if (this._ivp === undefined) {\r\n this._ivp = this._iv.slice(0, blockSize);\r\n this._iv2p = this._iv.slice(blockSize, blockSize + blockSize);\r\n }\r\n\r\n\r\n // Remember this block to use with next block\r\n var nextIv2p = words.slice(offset, offset + blockSize);\r\n\r\n // XOR with previous ciphertext\r\n xorBlock(words, this._ivp, offset, blockSize);\r\n\r\n // Block cipher\r\n cipher.encryptBlock(words, offset);\r\n\r\n // XOR with previous plaintext\r\n xorBlock(words, this._iv2p, offset, blockSize);\r\n\r\n this._ivp = words.slice(offset, offset + blockSize);\r\n this._iv2p = nextIv2p;\r\n }\r\n });\r\n\r\n /**\r\n * IGE decryptor.\r\n */\r\n IGE.Decryptor = IGE.extend({\r\n /**\r\n * Processes the data block at offset.\r\n *\r\n * @param {Array} words The data words to operate on.\r\n * @param {number} offset The offset where the block starts.\r\n *\r\n * @example\r\n *\r\n * mode.processBlock(data.words, offset);\r\n */\r\n processBlock: function (words, offset) {\r\n // Shortcuts\r\n var cipher = this._cipher;\r\n var blockSize = cipher.blockSize;\r\n\r\n if (this._ivp === undefined) {\r\n this._ivp = this._iv.slice(0, blockSize);\r\n this._iv2p = this._iv.slice(blockSize, 2 * blockSize);\r\n }\r\n\r\n // Remember this block to use with next block\r\n var nextIvp = words.slice(offset, offset + blockSize);\r\n\r\n // XOR with previous ciphertext\r\n xorBlock(words, this._iv2p, offset, blockSize);\r\n\r\n // Block cipher\r\n cipher.decryptBlock(words, offset);\r\n\r\n // XOR with previous plaintext\r\n xorBlock(words, this._ivp, offset, blockSize);\r\n\r\n this._ivp = nextIvp;\r\n this._iv2p = words.slice(offset, offset + blockSize);\r\n }\r\n });\r\n\r\n function xorBlock(words, block, offset, blockSize) {\r\n for (var i = 0; i < blockSize; i++) {\r\n words[offset + i] ^= block[i];\r\n }\r\n }\r\n\r\n return IGE;\r\n }());\r\n\r\n /**\r\n * Padding namespace.\r\n */\r\n var C_pad = C.pad = {};\r\n\r\n /**\r\n * PKCS #5/7 padding strategy.\r\n */\r\n var Pkcs7 = C_pad.Pkcs7 = {\r\n /**\r\n * Pads data using the algorithm defined in PKCS #5/7.\r\n *\r\n * @param {WordArray} data The data to pad.\r\n * @param {number} blockSize The multiple that the data should be padded to.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * CryptoJS.pad.Pkcs7.pad(wordArray, 4);\r\n */\r\n pad: function (data, blockSize) {\r\n // Shortcut\r\n var blockSizeBytes = blockSize * 4;\r\n\r\n // Count padding bytes\r\n var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;\r\n\r\n // Create padding word\r\n var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;\r\n\r\n // Create padding\r\n var paddingWords = [];\r\n for (var i = 0; i < nPaddingBytes; i += 4) {\r\n paddingWords.push(paddingWord);\r\n }\r\n var padding = WordArray.create(paddingWords, nPaddingBytes);\r\n\r\n // Add padding\r\n data.concat(padding);\r\n },\r\n\r\n /**\r\n * Unpads data that had been padded using the algorithm defined in PKCS #5/7.\r\n *\r\n * @param {WordArray} data The data to unpad.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * CryptoJS.pad.Pkcs7.unpad(wordArray);\r\n */\r\n unpad: function (data) {\r\n // Get number of padding bytes from last byte\r\n var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;\r\n\r\n // Remove padding\r\n data.sigBytes -= nPaddingBytes;\r\n }\r\n };\r\n\r\n var NoPadding = C_pad.NoPadding = {\r\n pad: function () {\r\n },\r\n\r\n unpad: function () {\r\n }\r\n };\r\n\r\n\r\n /**\r\n * Abstract base block cipher template.\r\n *\r\n * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits)\r\n */\r\n var BlockCipher = C_lib.BlockCipher = Cipher.extend({\r\n /**\r\n * Configuration options.\r\n *\r\n * @property {Mode} mode The block mode to use. Default: CBC\r\n * @property {Padding} padding The padding strategy to use. Default: Pkcs7\r\n */\r\n cfg: Cipher.cfg.extend({\r\n mode: CBC,\r\n padding: Pkcs7\r\n }),\r\n\r\n reset: function () {\r\n // Reset cipher\r\n Cipher.reset.call(this);\r\n\r\n // Shortcuts\r\n var cfg = this.cfg;\r\n var iv = cfg.iv;\r\n var mode = cfg.mode;\r\n\r\n // Reset block mode\r\n if (this._xformMode == this._ENC_XFORM_MODE) {\r\n var modeCreator = mode.createEncryptor;\r\n } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {\r\n var modeCreator = mode.createDecryptor;\r\n\r\n // Keep at least one block in the buffer for unpadding\r\n this._minBufferSize = 1;\r\n }\r\n this._mode = modeCreator.call(mode, this, iv && iv.words);\r\n },\r\n\r\n _doProcessBlock: function (words, offset) {\r\n this._mode.processBlock(words, offset);\r\n },\r\n\r\n _doFinalize: function () {\r\n // Shortcut\r\n var padding = this.cfg.padding;\r\n\r\n // Finalize\r\n if (this._xformMode == this._ENC_XFORM_MODE) {\r\n // Pad data\r\n padding.pad(this._data, this.blockSize);\r\n\r\n // Process final blocks\r\n var finalProcessedBlocks = this._process(!!'flush');\r\n } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {\r\n // Process final blocks\r\n var finalProcessedBlocks = this._process(!!'flush');\r\n\r\n // Unpad data\r\n padding.unpad(finalProcessedBlocks);\r\n }\r\n\r\n return finalProcessedBlocks;\r\n },\r\n\r\n blockSize: 128/32\r\n });\r\n\r\n /**\r\n * A collection of cipher parameters.\r\n *\r\n * @property {WordArray} ciphertext The raw ciphertext.\r\n * @property {WordArray} key The key to this ciphertext.\r\n * @property {WordArray} iv The IV used in the ciphering operation.\r\n * @property {WordArray} salt The salt used with a key derivation function.\r\n * @property {Cipher} algorithm The cipher algorithm.\r\n * @property {Mode} mode The block mode used in the ciphering operation.\r\n * @property {Padding} padding The padding scheme used in the ciphering operation.\r\n * @property {number} blockSize The block size of the cipher.\r\n * @property {Format} formatter The default formatting strategy to convert this cipher params object to a string.\r\n */\r\n var CipherParams = C_lib.CipherParams = Base.extend({\r\n /**\r\n * Initializes a newly created cipher params object.\r\n *\r\n * @param {Object} cipherParams An object with any of the possible cipher parameters.\r\n *\r\n * @example\r\n *\r\n * var cipherParams = CryptoJS.lib.CipherParams.create({\r\n * ciphertext: ciphertextWordArray,\r\n * key: keyWordArray,\r\n * iv: ivWordArray,\r\n * salt: saltWordArray,\r\n * algorithm: CryptoJS.algo.AES,\r\n * mode: CryptoJS.mode.CBC,\r\n * padding: CryptoJS.pad.PKCS7,\r\n * blockSize: 4,\r\n * formatter: CryptoJS.format.OpenSSL\r\n * });\r\n */\r\n init: function (cipherParams) {\r\n this.mixIn(cipherParams);\r\n },\r\n\r\n /**\r\n * Converts this cipher params object to a string.\r\n *\r\n * @param {Format} formatter (Optional) The formatting strategy to use.\r\n *\r\n * @return {string} The stringified cipher params.\r\n *\r\n * @throws Error If neither the formatter nor the default formatter is set.\r\n *\r\n * @example\r\n *\r\n * var string = cipherParams + '';\r\n * var string = cipherParams.toString();\r\n * var string = cipherParams.toString(CryptoJS.format.OpenSSL);\r\n */\r\n toString: function (formatter) {\r\n return (formatter || this.formatter).stringify(this);\r\n }\r\n });\r\n\r\n /**\r\n * Format namespace.\r\n */\r\n var C_format = C.format = {};\r\n\r\n /**\r\n * OpenSSL formatting strategy.\r\n */\r\n var OpenSSLFormatter = C_format.OpenSSL = {\r\n /**\r\n * Converts a cipher params object to an OpenSSL-compatible string.\r\n *\r\n * @param {CipherParams} cipherParams The cipher params object.\r\n *\r\n * @return {string} The OpenSSL-compatible string.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);\r\n */\r\n stringify: function (cipherParams) {\r\n // Shortcuts\r\n var ciphertext = cipherParams.ciphertext;\r\n var salt = cipherParams.salt;\r\n\r\n // Format\r\n if (salt) {\r\n var wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);\r\n } else {\r\n var wordArray = ciphertext;\r\n }\r\n\r\n return wordArray.toString(Base64);\r\n },\r\n\r\n /**\r\n * Converts an OpenSSL-compatible string to a cipher params object.\r\n *\r\n * @param {string} openSSLStr The OpenSSL-compatible string.\r\n *\r\n * @return {CipherParams} The cipher params object.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);\r\n */\r\n parse: function (openSSLStr) {\r\n // Parse base64\r\n var ciphertext = Base64.parse(openSSLStr);\r\n\r\n // Shortcut\r\n var ciphertextWords = ciphertext.words;\r\n\r\n // Test for salt\r\n if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {\r\n // Extract salt\r\n var salt = WordArray.create(ciphertextWords.slice(2, 4));\r\n\r\n // Remove salt from ciphertext\r\n ciphertextWords.splice(0, 4);\r\n ciphertext.sigBytes -= 16;\r\n }\r\n\r\n return CipherParams.create({ ciphertext: ciphertext, salt: salt });\r\n }\r\n };\r\n\r\n /**\r\n * A cipher wrapper that returns ciphertext as a serializable cipher params object.\r\n */\r\n var SerializableCipher = C_lib.SerializableCipher = Base.extend({\r\n /**\r\n * Configuration options.\r\n *\r\n * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL\r\n */\r\n cfg: Base.extend({\r\n format: OpenSSLFormatter\r\n }),\r\n\r\n /**\r\n * Encrypts a message.\r\n *\r\n * @param {Cipher} cipher The cipher algorithm to use.\r\n * @param {WordArray|string} message The message to encrypt.\r\n * @param {WordArray} key The key.\r\n * @param {Object} cfg (Optional) The configuration options to use for this operation.\r\n *\r\n * @return {CipherParams} A cipher params object.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);\r\n * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });\r\n * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });\r\n */\r\n encrypt: function (cipher, message, key, cfg) {\r\n // Apply config defaults\r\n cfg = this.cfg.extend(cfg);\r\n\r\n // Encrypt\r\n var encryptor = cipher.createEncryptor(key, cfg);\r\n var ciphertext = encryptor.finalize(message);\r\n\r\n // Shortcut\r\n var cipherCfg = encryptor.cfg;\r\n\r\n // Create and return serializable cipher params\r\n return CipherParams.create({\r\n ciphertext: ciphertext,\r\n key: key,\r\n iv: cipherCfg.iv,\r\n algorithm: cipher,\r\n mode: cipherCfg.mode,\r\n padding: cipherCfg.padding,\r\n blockSize: cipher.blockSize,\r\n formatter: cfg.format\r\n });\r\n },\r\n\r\n /**\r\n * Decrypts serialized ciphertext.\r\n *\r\n * @param {Cipher} cipher The cipher algorithm to use.\r\n * @param {CipherParams|string} ciphertext The ciphertext to decrypt.\r\n * @param {WordArray} key The key.\r\n * @param {Object} cfg (Optional) The configuration options to use for this operation.\r\n *\r\n * @return {WordArray} The plaintext.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });\r\n * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });\r\n */\r\n decrypt: function (cipher, ciphertext, key, cfg) {\r\n // Apply config defaults\r\n cfg = this.cfg.extend(cfg);\r\n\r\n // Convert string to CipherParams\r\n ciphertext = this._parse(ciphertext, cfg.format);\r\n\r\n // Decrypt\r\n var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);\r\n\r\n return plaintext;\r\n },\r\n\r\n /**\r\n * Converts serialized ciphertext to CipherParams,\r\n * else assumed CipherParams already and returns ciphertext unchanged.\r\n *\r\n * @param {CipherParams|string} ciphertext The ciphertext.\r\n * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.\r\n *\r\n * @return {CipherParams} The unserialized ciphertext.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);\r\n */\r\n _parse: function (ciphertext, format) {\r\n if (typeof ciphertext == 'string') {\r\n return format.parse(ciphertext, this);\r\n } else {\r\n return ciphertext;\r\n }\r\n }\r\n });\r\n\r\n /**\r\n * Key derivation function namespace.\r\n */\r\n var C_kdf = C.kdf = {};\r\n\r\n /**\r\n * OpenSSL key derivation function.\r\n */\r\n var OpenSSLKdf = C_kdf.OpenSSL = {\r\n /**\r\n * Derives a key and IV from a password.\r\n *\r\n * @param {string} password The password to derive from.\r\n * @param {number} keySize The size in words of the key to generate.\r\n * @param {number} ivSize The size in words of the IV to generate.\r\n * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.\r\n *\r\n * @return {CipherParams} A cipher params object with the key, IV, and salt.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);\r\n * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');\r\n */\r\n execute: function (password, keySize, ivSize, salt) {\r\n // Generate random salt\r\n if (!salt) {\r\n salt = WordArray.random(64/8);\r\n }\r\n\r\n // Derive key and IV\r\n var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);\r\n\r\n // Separate key and IV\r\n var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);\r\n key.sigBytes = keySize * 4;\r\n\r\n // Return params\r\n return CipherParams.create({ key: key, iv: iv, salt: salt });\r\n }\r\n };\r\n\r\n /**\r\n * A serializable cipher wrapper that derives the key from a password,\r\n * and returns ciphertext as a serializable cipher params object.\r\n */\r\n var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({\r\n /**\r\n * Configuration options.\r\n *\r\n * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL\r\n */\r\n cfg: SerializableCipher.cfg.extend({\r\n kdf: OpenSSLKdf\r\n }),\r\n\r\n /**\r\n * Encrypts a message using a password.\r\n *\r\n * @param {Cipher} cipher The cipher algorithm to use.\r\n * @param {WordArray|string} message The message to encrypt.\r\n * @param {string} password The password.\r\n * @param {Object} cfg (Optional) The configuration options to use for this operation.\r\n *\r\n * @return {CipherParams} A cipher params object.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');\r\n * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });\r\n */\r\n encrypt: function (cipher, message, password, cfg) {\r\n // Apply config defaults\r\n cfg = this.cfg.extend(cfg);\r\n\r\n // Derive key and other params\r\n var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize);\r\n\r\n // Add IV to config\r\n cfg.iv = derivedParams.iv;\r\n\r\n // Encrypt\r\n var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);\r\n\r\n // Mix in derived params\r\n ciphertext.mixIn(derivedParams);\r\n\r\n return ciphertext;\r\n },\r\n\r\n /**\r\n * Decrypts serialized ciphertext using a password.\r\n *\r\n * @param {Cipher} cipher The cipher algorithm to use.\r\n * @param {CipherParams|string} ciphertext The ciphertext to decrypt.\r\n * @param {string} password The password.\r\n * @param {Object} cfg (Optional) The configuration options to use for this operation.\r\n *\r\n * @return {WordArray} The plaintext.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });\r\n * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });\r\n */\r\n decrypt: function (cipher, ciphertext, password, cfg) {\r\n // Apply config defaults\r\n cfg = this.cfg.extend(cfg);\r\n\r\n // Convert string to CipherParams\r\n ciphertext = this._parse(ciphertext, cfg.format);\r\n\r\n // Derive key and other params\r\n var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);\r\n\r\n // Add IV to config\r\n cfg.iv = derivedParams.iv;\r\n\r\n // Decrypt\r\n var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);\r\n\r\n return plaintext;\r\n }\r\n });\r\n}());\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/@goodmind/node-cryptojs-aes/lib/cipher-core.js\n// module id = 5\n// module chunks = 0","var CryptoJS = require('./core').CryptoJS;\n\n/*\nCryptoJS v3.1.2\ncode.google.com/p/crypto-js\n(c) 2009-2013 by Jeff Mott. All rights reserved.\ncode.google.com/p/crypto-js/wiki/License\n*/\n(function () {\n // Shortcuts\n var C = CryptoJS;\n var C_lib = C.lib;\n var WordArray = C_lib.WordArray;\n var C_enc = C.enc;\n\n /**\n * Base64 encoding strategy.\n */\n var Base64 = C_enc.Base64 = {\n /**\n * Converts a word array to a Base64 string.\n *\n * @param {WordArray} wordArray The word array.\n *\n * @return {string} The Base64 string.\n *\n * @static\n *\n * @example\n *\n * var base64String = CryptoJS.enc.Base64.stringify(wordArray);\n */\n stringify: function (wordArray) {\n // Shortcuts\n var words = wordArray.words;\n var sigBytes = wordArray.sigBytes;\n var map = this._map;\n\n // Clamp excess bits\n wordArray.clamp();\n\n // Convert\n var base64Chars = [];\n for (var i = 0; i < sigBytes; i += 3) {\n var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;\n var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;\n\n var triplet = (byte1 << 16) | (byte2 << 8) | byte3;\n\n for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {\n base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));\n }\n }\n\n // Add padding\n var paddingChar = map.charAt(64);\n if (paddingChar) {\n while (base64Chars.length % 4) {\n base64Chars.push(paddingChar);\n }\n }\n\n return base64Chars.join('');\n },\n\n /**\n * Converts a Base64 string to a word array.\n *\n * @param {string} base64Str The Base64 string.\n *\n * @return {WordArray} The word array.\n *\n * @static\n *\n * @example\n *\n * var wordArray = CryptoJS.enc.Base64.parse(base64String);\n */\n parse: function (base64Str) {\n // Shortcuts\n var base64StrLength = base64Str.length;\n var map = this._map;\n\n // Ignore padding\n var paddingChar = map.charAt(64);\n if (paddingChar) {\n var paddingIndex = base64Str.indexOf(paddingChar);\n if (paddingIndex != -1) {\n base64StrLength = paddingIndex;\n }\n }\n\n // Convert\n var words = [];\n var nBytes = 0;\n for (var i = 0; i < base64StrLength; i++) {\n if (i % 4) {\n var bits1 = map.indexOf(base64Str.charAt(i - 1)) << ((i % 4) * 2);\n var bits2 = map.indexOf(base64Str.charAt(i)) >>> (6 - (i % 4) * 2);\n words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);\n nBytes++;\n }\n }\n\n return WordArray.create(words, nBytes);\n },\n\n _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='\n };\n}());\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/@goodmind/node-cryptojs-aes/lib/enc-base64.js\n// module id = 6\n// module chunks = 0","var CryptoJS = require('./core').CryptoJS;\r\n\r\n/*\nCryptoJS v3.1.2\ncode.google.com/p/crypto-js\n(c) 2009-2013 by Jeff Mott. All rights reserved.\ncode.google.com/p/crypto-js/wiki/License\n*/\n(function () {\r\n // Shortcuts\r\n var C = CryptoJS;\r\n var C_lib = C.lib;\r\n var Base = C_lib.Base;\r\n var WordArray = C_lib.WordArray;\r\n var C_algo = C.algo;\r\n var MD5 = C_algo.MD5;\r\n\r\n /**\r\n * This key derivation function is meant to conform with EVP_BytesToKey.\r\n * www.openssl.org/docs/crypto/EVP_BytesToKey.html\r\n */\r\n var EvpKDF = C_algo.EvpKDF = Base.extend({\r\n /**\r\n * Configuration options.\r\n *\r\n * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)\r\n * @property {Hasher} hasher The hash algorithm to use. Default: MD5\r\n * @property {number} iterations The number of iterations to perform. Default: 1\r\n */\r\n cfg: Base.extend({\r\n keySize: 128/32,\r\n hasher: MD5,\r\n iterations: 1\r\n }),\r\n\r\n /**\r\n * Initializes a newly created key derivation function.\r\n *\r\n * @param {Object} cfg (Optional) The configuration options to use for the derivation.\r\n *\r\n * @example\r\n *\r\n * var kdf = CryptoJS.algo.EvpKDF.create();\r\n * var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });\r\n * var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });\r\n */\r\n init: function (cfg) {\r\n this.cfg = this.cfg.extend(cfg);\r\n },\r\n\r\n /**\r\n * Derives a key from a password.\r\n *\r\n * @param {WordArray|string} password The password.\r\n * @param {WordArray|string} salt A salt.\r\n *\r\n * @return {WordArray} The derived key.\r\n *\r\n * @example\r\n *\r\n * var key = kdf.compute(password, salt);\r\n */\r\n compute: function (password, salt) {\r\n // Shortcut\r\n var cfg = this.cfg;\r\n\r\n // Init hasher\r\n var hasher = cfg.hasher.create();\r\n\r\n // Initial values\r\n var derivedKey = WordArray.create();\r\n\r\n // Shortcuts\r\n var derivedKeyWords = derivedKey.words;\r\n var keySize = cfg.keySize;\r\n var iterations = cfg.iterations;\r\n\r\n // Generate key\r\n while (derivedKeyWords.length < keySize) {\r\n if (block) {\r\n hasher.update(block);\r\n }\r\n var block = hasher.update(password).finalize(salt);\r\n hasher.reset();\r\n\r\n // Iterations\r\n for (var i = 1; i < iterations; i++) {\r\n block = hasher.finalize(block);\r\n hasher.reset();\r\n }\r\n\r\n derivedKey.concat(block);\r\n }\r\n derivedKey.sigBytes = keySize * 4;\r\n\r\n return derivedKey;\r\n }\r\n });\r\n\r\n /**\r\n * Derives a key from a password.\r\n *\r\n * @param {WordArray|string} password The password.\r\n * @param {WordArray|string} salt A salt.\r\n * @param {Object} cfg (Optional) The configuration options to use for this computation.\r\n *\r\n * @return {WordArray} The derived key.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var key = CryptoJS.EvpKDF(password, salt);\r\n * var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });\r\n * var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });\r\n */\r\n C.EvpKDF = function (password, salt, cfg) {\r\n return EvpKDF.create(cfg).compute(password, salt);\r\n };\r\n}());\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/@goodmind/node-cryptojs-aes/lib/evpkdf.js\n// module id = 7\n// module chunks = 0","var CryptoJS = require('./core').CryptoJS;\n\n// create custom json serialization format\nvar JsonFormatter = {\n\tstringify: function (cipherParams) {\n\t\t// create json object with ciphertext\n\t\tvar jsonObj = {\n\t\t\tct: cipherParams.ciphertext.toString(CryptoJS.enc.Base64)\n\t\t};\n\t\t\n\t\t// optionally add iv and salt\n\t\tif (cipherParams.iv) {\n\t\t\tjsonObj.iv = cipherParams.iv.toString();\n\t\t}\n\t\t\n\t\tif (cipherParams.salt) {\n\t\t\tjsonObj.s = cipherParams.salt.toString();\n\t\t}\n\n\t\t// stringify json object\n\t\treturn JSON.stringify(jsonObj)\n\t},\n\n\tparse: function (jsonStr) {\n\t\t// parse json string\n\t\tvar jsonObj = JSON.parse(jsonStr);\n\t\t\n\t\t// extract ciphertext from json object, and create cipher params object\n\t\tvar cipherParams = CryptoJS.lib.CipherParams.create({\n\t\t\tciphertext: CryptoJS.enc.Base64.parse(jsonObj.ct)\n\t\t});\n\t\t\n\t\t// optionally extract iv and salt\n\t\tif (jsonObj.iv) {\n\t\t\tcipherParams.iv = CryptoJS.enc.Hex.parse(jsonObj.iv);\n\t\t}\n \n\t\tif (jsonObj.s) {\n\t\t\tcipherParams.salt = CryptoJS.enc.Hex.parse(jsonObj.s);\n\t\t}\n\t\t\n\t\treturn cipherParams;\n\t}\n};\n\nexports.JsonFormatter = JsonFormatter;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/@goodmind/node-cryptojs-aes/lib/jsonformatter.js\n// module id = 8\n// module chunks = 0","var CryptoJS = require('./core').CryptoJS;\r\n\r\n/*\nCryptoJS v3.1.2\ncode.google.com/p/crypto-js\n(c) 2009-2013 by Jeff Mott. All rights reserved.\ncode.google.com/p/crypto-js/wiki/License\n*/\n(function (Math) {\r\n // Shortcuts\r\n var C = CryptoJS;\r\n var C_lib = C.lib;\r\n var WordArray = C_lib.WordArray;\r\n var Hasher = C_lib.Hasher;\r\n var C_algo = C.algo;\r\n\r\n // Constants table\r\n var T = [];\r\n\r\n // Compute constants\r\n (function () {\r\n for (var i = 0; i < 64; i++) {\r\n T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;\r\n }\r\n }());\r\n\r\n /**\r\n * MD5 hash algorithm.\r\n */\r\n var MD5 = C_algo.MD5 = Hasher.extend({\r\n _doReset: function () {\r\n this._hash = new WordArray.init([\r\n 0x67452301, 0xefcdab89,\r\n 0x98badcfe, 0x10325476\r\n ]);\r\n },\r\n\r\n _doProcessBlock: function (M, offset) {\r\n // Swap endian\r\n for (var i = 0; i < 16; i++) {\r\n // Shortcuts\r\n var offset_i = offset + i;\r\n var M_offset_i = M[offset_i];\r\n\r\n M[offset_i] = (\r\n (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) |\r\n (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)\r\n );\r\n }\r\n\r\n // Shortcuts\r\n var H = this._hash.words;\r\n\r\n var M_offset_0 = M[offset + 0];\r\n var M_offset_1 = M[offset + 1];\r\n var M_offset_2 = M[offset + 2];\r\n var M_offset_3 = M[offset + 3];\r\n var M_offset_4 = M[offset + 4];\r\n var M_offset_5 = M[offset + 5];\r\n var M_offset_6 = M[offset + 6];\r\n var M_offset_7 = M[offset + 7];\r\n var M_offset_8 = M[offset + 8];\r\n var M_offset_9 = M[offset + 9];\r\n var M_offset_10 = M[offset + 10];\r\n var M_offset_11 = M[offset + 11];\r\n var M_offset_12 = M[offset + 12];\r\n var M_offset_13 = M[offset + 13];\r\n var M_offset_14 = M[offset + 14];\r\n var M_offset_15 = M[offset + 15];\r\n\r\n // Working varialbes\r\n var a = H[0];\r\n var b = H[1];\r\n var c = H[2];\r\n var d = H[3];\r\n\r\n // Computation\r\n a = FF(a, b, c, d, M_offset_0, 7, T[0]);\r\n d = FF(d, a, b, c, M_offset_1, 12, T[1]);\r\n c = FF(c, d, a, b, M_offset_2, 17, T[2]);\r\n b = FF(b, c, d, a, M_offset_3, 22, T[3]);\r\n a = FF(a, b, c, d, M_offset_4, 7, T[4]);\r\n d = FF(d, a, b, c, M_offset_5, 12, T[5]);\r\n c = FF(c, d, a, b, M_offset_6, 17, T[6]);\r\n b = FF(b, c, d, a, M_offset_7, 22, T[7]);\r\n a = FF(a, b, c, d, M_offset_8, 7, T[8]);\r\n d = FF(d, a, b, c, M_offset_9, 12, T[9]);\r\n c = FF(c, d, a, b, M_offset_10, 17, T[10]);\r\n b = FF(b, c, d, a, M_offset_11, 22, T[11]);\r\n a = FF(a, b, c, d, M_offset_12, 7, T[12]);\r\n d = FF(d, a, b, c, M_offset_13, 12, T[13]);\r\n c = FF(c, d, a, b, M_offset_14, 17, T[14]);\r\n b = FF(b, c, d, a, M_offset_15, 22, T[15]);\r\n\r\n a = GG(a, b, c, d, M_offset_1, 5, T[16]);\r\n d = GG(d, a, b, c, M_offset_6, 9, T[17]);\r\n c = GG(c, d, a, b, M_offset_11, 14, T[18]);\r\n b = GG(b, c, d, a, M_offset_0, 20, T[19]);\r\n a = GG(a, b, c, d, M_offset_5, 5, T[20]);\r\n d = GG(d, a, b, c, M_offset_10, 9, T[21]);\r\n c = GG(c, d, a, b, M_offset_15, 14, T[22]);\r\n b = GG(b, c, d, a, M_offset_4, 20, T[23]);\r\n a = GG(a, b, c, d, M_offset_9, 5, T[24]);\r\n d = GG(d, a, b, c, M_offset_14, 9, T[25]);\r\n c = GG(c, d, a, b, M_offset_3, 14, T[26]);\r\n b = GG(b, c, d, a, M_offset_8, 20, T[27]);\r\n a = GG(a, b, c, d, M_offset_13, 5, T[28]);\r\n d = GG(d, a, b, c, M_offset_2, 9, T[29]);\r\n c = GG(c, d, a, b, M_offset_7, 14, T[30]);\r\n b = GG(b, c, d, a, M_offset_12, 20, T[31]);\r\n\r\n a = HH(a, b, c, d, M_offset_5, 4, T[32]);\r\n d = HH(d, a, b, c, M_offset_8, 11, T[33]);\r\n c = HH(c, d, a, b, M_offset_11, 16, T[34]);\r\n b = HH(b, c, d, a, M_offset_14, 23, T[35]);\r\n a = HH(a, b, c, d, M_offset_1, 4, T[36]);\r\n d = HH(d, a, b, c, M_offset_4, 11, T[37]);\r\n c = HH(c, d, a, b, M_offset_7, 16, T[38]);\r\n b = HH(b, c, d, a, M_offset_10, 23, T[39]);\r\n a = HH(a, b, c, d, M_offset_13, 4, T[40]);\r\n d = HH(d, a, b, c, M_offset_0, 11, T[41]);\r\n c = HH(c, d, a, b, M_offset_3, 16, T[42]);\r\n b = HH(b, c, d, a, M_offset_6, 23, T[43]);\r\n a = HH(a, b, c, d, M_offset_9, 4, T[44]);\r\n d = HH(d, a, b, c, M_offset_12, 11, T[45]);\r\n c = HH(c, d, a, b, M_offset_15, 16, T[46]);\r\n b = HH(b, c, d, a, M_offset_2, 23, T[47]);\r\n\r\n a = II(a, b, c, d, M_offset_0, 6, T[48]);\r\n d = II(d, a, b, c, M_offset_7, 10, T[49]);\r\n c = II(c, d, a, b, M_offset_14, 15, T[50]);\r\n b = II(b, c, d, a, M_offset_5, 21, T[51]);\r\n a = II(a, b, c, d, M_offset_12, 6, T[52]);\r\n d = II(d, a, b, c, M_offset_3, 10, T[53]);\r\n c = II(c, d, a, b, M_offset_10, 15, T[54]);\r\n b = II(b, c, d, a, M_offset_1, 21, T[55]);\r\n a = II(a, b, c, d, M_offset_8, 6, T[56]);\r\n d = II(d, a, b, c, M_offset_15, 10, T[57]);\r\n c = II(c, d, a, b, M_offset_6, 15, T[58]);\r\n b = II(b, c, d, a, M_offset_13, 21, T[59]);\r\n a = II(a, b, c, d, M_offset_4, 6, T[60]);\r\n d = II(d, a, b, c, M_offset_11, 10, T[61]);\r\n c = II(c, d, a, b, M_offset_2, 15, T[62]);\r\n b = II(b, c, d, a, M_offset_9, 21, T[63]);\r\n\r\n // Intermediate hash value\r\n H[0] = (H[0] + a) | 0;\r\n H[1] = (H[1] + b) | 0;\r\n H[2] = (H[2] + c) | 0;\r\n H[3] = (H[3] + d) | 0;\r\n },\r\n\r\n _doFinalize: function () {\r\n // Shortcuts\r\n var data = this._data;\r\n var dataWords = data.words;\r\n\r\n var nBitsTotal = this._nDataBytes * 8;\r\n var nBitsLeft = data.sigBytes * 8;\r\n\r\n // Add padding\r\n dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);\r\n\r\n var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);\r\n var nBitsTotalL = nBitsTotal;\r\n dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (\r\n (((nBitsTotalH << 8) | (nBitsTotalH >>> 24)) & 0x00ff00ff) |\r\n (((nBitsTotalH << 24) | (nBitsTotalH >>> 8)) & 0xff00ff00)\r\n );\r\n dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (\r\n (((nBitsTotalL << 8) | (nBitsTotalL >>> 24)) & 0x00ff00ff) |\r\n (((nBitsTotalL << 24) | (nBitsTotalL >>> 8)) & 0xff00ff00)\r\n );\r\n\r\n data.sigBytes = (dataWords.length + 1) * 4;\r\n\r\n // Hash final blocks\r\n this._process();\r\n\r\n // Shortcuts\r\n var hash = this._hash;\r\n var H = hash.words;\r\n\r\n // Swap endian\r\n for (var i = 0; i < 4; i++) {\r\n // Shortcut\r\n var H_i = H[i];\r\n\r\n H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) |\r\n (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00);\r\n }\r\n\r\n // Return final computed hash\r\n return hash;\r\n },\r\n\r\n clone: function () {\r\n var clone = Hasher.clone.call(this);\r\n clone._hash = this._hash.clone();\r\n\r\n return clone;\r\n }\r\n });\r\n\r\n function FF(a, b, c, d, x, s, t) {\r\n var n = a + ((b & c) | (~b & d)) + x + t;\r\n return ((n << s) | (n >>> (32 - s))) + b;\r\n }\r\n\r\n function GG(a, b, c, d, x, s, t) {\r\n var n = a + ((b & d) | (c & ~d)) + x + t;\r\n return ((n << s) | (n >>> (32 - s))) + b;\r\n }\r\n\r\n function HH(a, b, c, d, x, s, t) {\r\n var n = a + (b ^ c ^ d) + x + t;\r\n return ((n << s) | (n >>> (32 - s))) + b;\r\n }\r\n\r\n function II(a, b, c, d, x, s, t) {\r\n var n = a + (c ^ (b | ~d)) + x + t;\r\n return ((n << s) | (n >>> (32 - s))) + b;\r\n }\r\n\r\n /**\r\n * Shortcut function to the hasher's object interface.\r\n *\r\n * @param {WordArray|string} message The message to hash.\r\n *\r\n * @return {WordArray} The hash.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var hash = CryptoJS.MD5('message');\r\n * var hash = CryptoJS.MD5(wordArray);\r\n */\r\n C.MD5 = Hasher._createHelper(MD5);\r\n\r\n /**\r\n * Shortcut function to the HMAC's object interface.\r\n *\r\n * @param {WordArray|string} message The message to hash.\r\n * @param {WordArray|string} key The secret key.\r\n *\r\n * @return {WordArray} The HMAC.\r\n *\r\n * @static\r\n *\r\n * @example\r\n *\r\n * var hmac = CryptoJS.HmacMD5(message, key);\r\n */\r\n C.HmacMD5 = Hasher._createHmacHelper(MD5);\r\n}(Math));\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/@goodmind/node-cryptojs-aes/lib/md5.js\n// module id = 9\n// module chunks = 0","var CryptoJS = require('./core').CryptoJS;\n\n(function (Math) {\n // Shortcuts\n var C = CryptoJS;\n var C_lib = C.lib;\n var WordArray = C_lib.WordArray;\n var Hasher = C_lib.Hasher;\n var C_algo = C.algo;\n\n // Initialization and round constants tables\n var H = [];\n var K = [];\n\n // Compute constants\n (function () {\n function isPrime(n) {\n var sqrtN = Math.sqrt(n);\n for (var factor = 2; factor <= sqrtN; factor++) {\n if (!(n % factor)) {\n return false;\n }\n }\n\n return true;\n }\n\n function getFractionalBits(n) {\n return ((n - (n | 0)) * 0x100000000) | 0;\n }\n\n var n = 2;\n var nPrime = 0;\n while (nPrime < 64) {\n if (isPrime(n)) {\n if (nPrime < 8) {\n H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));\n }\n K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));\n\n nPrime++;\n }\n\n n++;\n }\n }());\n\n // Reusable object\n var W = [];\n\n /**\n * SHA-256 hash algorithm.\n */\n var SHA256 = C_algo.SHA256 = Hasher.extend({\n _doReset: function () {\n this._hash = new WordArray.init(H.slice(0));\n },\n\n _doProcessBlock: function (M, offset) {\n // Shortcut\n var H = this._hash.words;\n\n // Working variables\n var a = H[0];\n var b = H[1];\n var c = H[2];\n var d = H[3];\n var e = H[4];\n var f = H[5];\n var g = H[6];\n var h = H[7];\n\n // Computation\n for (var i = 0; i < 64; i++) {\n if (i < 16) {\n W[i] = M[offset + i] | 0;\n } else {\n var gamma0x = W[i - 15];\n var gamma0 = ((gamma0x << 25) | (gamma0x >>> 7)) ^\n ((gamma0x << 14) | (gamma0x >>> 18)) ^\n (gamma0x >>> 3);\n\n var gamma1x = W[i - 2];\n var gamma1 = ((gamma1x << 15) | (gamma1x >>> 17)) ^\n ((gamma1x << 13) | (gamma1x >>> 19)) ^\n (gamma1x >>> 10);\n\n W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];\n }\n\n var ch = (e & f) ^ (~e & g);\n var maj = (a & b) ^ (a & c) ^ (b & c);\n\n var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));\n var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7) | (e >>> 25));\n\n var t1 = h + sigma1 + ch + K[i] + W[i];\n var t2 = sigma0 + maj;\n\n h = g;\n g = f;\n f = e;\n e = (d + t1) | 0;\n d = c;\n c = b;\n b = a;\n a = (t1 + t2) | 0;\n }\n\n // Intermediate hash value\n H[0] = (H[0] + a) | 0;\n H[1] = (H[1] + b) | 0;\n H[2] = (H[2] + c) | 0;\n H[3] = (H[3] + d) | 0;\n H[4] = (H[4] + e) | 0;\n H[5] = (H[5] + f) | 0;\n H[6] = (H[6] + g) | 0;\n H[7] = (H[7] + h) | 0;\n },\n\n _doFinalize: function () {\n // Shortcuts\n var data = this._data;\n var dataWords = data.words;\n\n var nBitsTotal = this._nDataBytes * 8;\n var nBitsLeft = data.sigBytes * 8;\n\n // Add padding\n dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);\n dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);\n dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;\n data.sigBytes = dataWords.length * 4;\n\n // Hash final blocks\n this._process();\n\n // Return final computed hash\n return this._hash;\n },\n\n clone: function () {\n var clone = Hasher.clone.call(this);\n clone._hash = this._hash.clone();\n\n return clone;\n }\n });\n\n /**\n * Shortcut function to the hasher's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n *\n * @return {WordArray} The hash.\n *\n * @static\n *\n * @example\n *\n * var hash = CryptoJS.SHA256('message');\n * var hash = CryptoJS.SHA256(wordArray);\n */\n C.SHA256 = Hasher._createHelper(SHA256);\n\n /**\n * Shortcut function to the HMAC's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n * @param {WordArray|string} key The secret key.\n *\n * @return {WordArray} The HMAC.\n *\n * @static\n *\n * @example\n *\n * var hmac = CryptoJS.HmacSHA256(message, key);\n */\n C.HmacSHA256 = Hasher._createHmacHelper(SHA256);\n}(Math));\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/@goodmind/node-cryptojs-aes/lib/sha256.js\n// module id = 10\n// module chunks = 0","////////////////////////////////////////////////////////////////////////////////////////\r\n// Big Integer Library v. 5.5\r\n// Created 2000, last modified 2013\r\n// Leemon Baird\r\n// www.leemon.com\r\n//\r\n// Version history:\r\n// v 5.5 17 Mar 2013\r\n// - two lines of a form like \"if (x<0) x+=n\" had the \"if\" changed to \"while\" to\r\n// handle the case when x<-n. (Thanks to James Ansell for finding that bug)\r\n// v 5.4 3 Oct 2009\r\n// - added \"var i\" to greaterShift() so i is not global. (Thanks to PŽter Szab— for finding that bug)\r\n//\r\n// v 5.3 21 Sep 2009\r\n// - added randProbPrime(k) for probable primes\r\n// - unrolled loop in mont_ (slightly faster)\r\n// - millerRabin now takes a bigInt parameter rather than an int\r\n//\r\n// v 5.2 15 Sep 2009\r\n// - fixed capitalization in call to int2bigInt in randBigInt\r\n// (thanks to Emili Evripidou, Reinhold Behringer, and Samuel Macaleese for finding that bug)\r\n//\r\n// v 5.1 8 Oct 2007\r\n// - renamed inverseModInt_ to inverseModInt since it doesn't change its parameters\r\n// - added functions GCD and randBigInt, which call GCD_ and randBigInt_\r\n// - fixed a bug found by Rob Visser (see comment with his name below)\r\n// - improved comments\r\n//\r\n// This file is public domain. You can use it for any purpose without restriction.\r\n// I do not guarantee that it is correct, so use it at your own risk. If you use\r\n// it for something interesting, I'd appreciate hearing about it. If you find\r\n// any bugs or make any improvements, I'd appreciate hearing about those too.\r\n// It would also be nice if my name and URL were left in the comments. But none\r\n// of that is required.\r\n//\r\n// This code defines a bigInt library for arbitrary-precision integers.\r\n// A bigInt is an array of integers storing the value in chunks of bpe bits,\r\n// little endian (buff[0] is the least significant word).\r\n// Negative bigInts are stored two's complement. Almost all the functions treat\r\n// bigInts as nonnegative. The few that view them as two's complement say so\r\n// in their comments. Some functions assume their parameters have at least one\r\n// leading zero element. Functions with an underscore at the end of the name put\r\n// their answer into one of the arrays passed in, and have unpredictable behavior\r\n// in case of overflow, so the caller must make sure the arrays are big enough to\r\n// hold the answer. But the average user should never have to call any of the\r\n// underscored functions. Each important underscored function has a wrapper function\r\n// of the same name without the underscore that takes care of the details for you.\r\n// For each underscored function where a parameter is modified, that same variable\r\n// must not be used as another argument too. So, you cannot square x by doing\r\n// multMod_(x,x,n). You must use squareMod_(x,n) instead, or do y=dup(x); multMod_(x,y,n).\r\n// Or simply use the multMod(x,x,n) function without the underscore, where\r\n// such issues never arise, because non-underscored functions never change\r\n// their parameters; they always allocate new memory for the answer that is returned.\r\n//\r\n// These functions are designed to avoid frequent dynamic memory allocation in the inner loop.\r\n// For most functions, if it needs a BigInt as a local variable it will actually use\r\n// a global, and will only allocate to it only when it's not the right size. This ensures\r\n// that when a function is called repeatedly with same-sized parameters, it only allocates\r\n// memory on the first call.\r\n//\r\n// Note that for cryptographic purposes, the calls to Math.random() must\r\n// be replaced with calls to a better pseudorandom number generator.\r\n//\r\n// In the following, \"bigInt\" means a bigInt with at least one leading zero element,\r\n// and \"integer\" means a nonnegative integer less than radix. In some cases, integer\r\n// can be negative. Negative bigInts are 2s complement.\r\n//\r\n// The following functions do not modify their inputs.\r\n// Those returning a bigInt, string, or Array will dynamically allocate memory for that value.\r\n// Those returning a boolean will return the integer 0 (false) or 1 (true).\r\n// Those returning boolean or int will not allocate memory except possibly on the first\r\n// time they're called with a given parameter size.\r\n//\r\n// bigInt add(x,y) //return (x+y) for bigInts x and y.\r\n// bigInt addInt(x,n) //return (x+n) where x is a bigInt and n is an integer.\r\n// string bigInt2str(x,base) //return a string form of bigInt x in a given base, with 2 <= base <= 95\r\n// int bitSize(x) //return how many bits long the bigInt x is, not counting leading zeros\r\n// bigInt dup(x) //return a copy of bigInt x\r\n// boolean equals(x,y) //is the bigInt x equal to the bigint y?\r\n// boolean equalsInt(x,y) //is bigint x equal to integer y?\r\n// bigInt expand(x,n) //return a copy of x with at least n elements, adding leading zeros if needed\r\n// Array findPrimes(n) //return array of all primes less than integer n\r\n// bigInt GCD(x,y) //return greatest common divisor of bigInts x and y (each with same number of elements).\r\n// boolean greater(x,y) //is x>y? (x and y are nonnegative bigInts)\r\n// boolean greaterShift(x,y,shift)//is (x <<(shift*bpe)) > y?\r\n// bigInt int2bigInt(t,n,m) //return a bigInt equal to integer t, with at least n bits and m array elements\r\n// bigInt inverseMod(x,n) //return (x**(-1) mod n) for bigInts x and n. If no inverse exists, it returns null\r\n// int inverseModInt(x,n) //return x**(-1) mod n, for integers x and n. Return 0 if there is no inverse\r\n// boolean isZero(x) //is the bigInt x equal to zero?\r\n// boolean millerRabin(x,b) //does one round of Miller-Rabin base integer b say that bigInt x is possibly prime? (b is bigInt, 1<b<x)\r\n// boolean millerRabinInt(x,b) //does one round of Miller-Rabin base integer b say that bigInt x is possibly prime? (b is int, 1<b<x)\r\n// bigInt mod(x,n) //return a new bigInt equal to (x mod n) for bigInts x and n.\r\n// int modInt(x,n) //return x mod n for bigInt x and integer n.\r\n// bigInt mult(x,y) //return x*y for bigInts x and y. This is faster when y<x.\r\n// bigInt multMod(x,y,n) //return (x*y mod n) for bigInts x,y,n. For greater speed, let y<x.\r\n// boolean negative(x) //is bigInt x negative?\r\n// bigInt powMod(x,y,n) //return (x**y mod n) where x,y,n are bigInts and ** is exponentiation. 0**0=1. Faster for odd n.\r\n// bigInt randBigInt(n,s) //return an n-bit random BigInt (n>=1). If s=1, then the most significant of those n bits is set to 1.\r\n// bigInt randTruePrime(k) //return a new, random, k-bit, true prime bigInt using Maurer's algorithm.\r\n// bigInt randProbPrime(k) //return a new, random, k-bit, probable prime bigInt (probability it's composite less than 2^-80).\r\n// bigInt str2bigInt(s,b,n,m) //return a bigInt for number represented in string s in base b with at least n bits and m array elements\r\n// bigInt sub(x,y) //return (x-y) for bigInts x and y. Negative answers will be 2s complement\r\n// bigInt trim(x,k) //return a copy of x with exactly k leading zero elements\r\n//\r\n//\r\n// The following functions each have a non-underscored version, which most users should call instead.\r\n// These functions each write to a single parameter, and the caller is responsible for ensuring the array\r\n// passed in is large enough to hold the result.\r\n//\r\n// void addInt_(x,n) //do x=x+n where x is a bigInt and n is an integer\r\n// void add_(x,y) //do x=x+y for bigInts x and y\r\n// void copy_(x,y) //do x=y on bigInts x and y\r\n// void copyInt_(x,n) //do x=n on bigInt x and integer n\r\n// void GCD_(x,y) //set x to the greatest common divisor of bigInts x and y, (y is destroyed). (This never overflows its array).\r\n// boolean inverseMod_(x,n) //do x=x**(-1) mod n, for bigInts x and n. Returns 1 (0) if inverse does (doesn't) exist\r\n// void mod_(x,n) //do x=x mod n for bigInts x and n. (This never overflows its array).\r\n// void mult_(x,y) //do x=x*y for bigInts x and y.\r\n// void multMod_(x,y,n) //do x=x*y mod n for bigInts x,y,n.\r\n// void powMod_(x,y,n) //do x=x**y mod n, where x,y,n are bigInts (n is odd) and ** is exponentiation. 0**0=1.\r\n// void randBigInt_(b,n,s) //do b = an n-bit random BigInt. if s=1, then nth bit (most significant bit) is set to 1. n>=1.\r\n// void randTruePrime_(ans,k) //do ans = a random k-bit true random prime (not just probable prime) with 1 in the msb.\r\n// void sub_(x,y) //do x=x-y for bigInts x and y. Negative answers will be 2s complement.\r\n//\r\n// The following functions do NOT have a non-underscored version.\r\n// They each write a bigInt result to one or more parameters. The caller is responsible for\r\n// ensuring the arrays passed in are large enough to hold the results.\r\n//\r\n// void addShift_(x,y,ys) //do x=x+(y<<(ys*bpe))\r\n// void carry_(x) //do carries and borrows so each element of the bigInt x fits in bpe bits.\r\n// void divide_(x,y,q,r) //divide x by y giving quotient q and remainder r\r\n// int divInt_(x,n) //do x=floor(x/n) for bigInt x and integer n, and return the remainder. (This never overflows its array).\r\n// int eGCD_(x,y,d,a,b) //sets a,b,d to positive bigInts such that d = GCD_(x,y) = a*x-b*y\r\n// void halve_(x) //do x=floor(|x|/2)*sgn(x) for bigInt x in 2's complement. (This never overflows its array).\r\n// void leftShift_(x,n) //left shift bigInt x by n bits. n<bpe.\r\n// void linComb_(x,y,a,b) //do x=a*x+b*y for bigInts x and y and integers a and b\r\n// void linCombShift_(x,y,b,ys) //do x=x+b*(y<<(ys*bpe)) for bigInts x and y, and integers b and ys\r\n// void mont_(x,y,n,np) //Montgomery multiplication (see comments where the function is defined)\r\n// void multInt_(x,n) //do x=x*n where x is a bigInt and n is an integer.\r\n// void rightShift_(x,n) //right shift bigInt x by n bits. 0 <= n < bpe. (This never overflows its array).\r\n// void squareMod_(x,n) //do x=x*x mod n for bigInts x,n\r\n// void subShift_(x,y,ys) //do x=x-(y<<(ys*bpe)). Negative answers will be 2s complement.\r\n//\r\n// The following functions are based on algorithms from the _Handbook of Applied Cryptography_\r\n// powMod_() = algorithm 14.94, Montgomery exponentiation\r\n// eGCD_,inverseMod_() = algorithm 14.61, Binary extended GCD_\r\n// GCD_() = algorothm 14.57, Lehmer's algorithm\r\n// mont_() = algorithm 14.36, Montgomery multiplication\r\n// divide_() = algorithm 14.20 Multiple-precision division\r\n// squareMod_() = algorithm 14.16 Multiple-precision squaring\r\n// randTruePrime_() = algorithm 4.62, Maurer's algorithm\r\n// millerRabin() = algorithm 4.24, Miller-Rabin algorithm\r\n//\r\n// Profiling shows:\r\n// randTruePrime_() spends:\r\n// 10% of its time in calls to powMod_()\r\n// 85% of its time in calls to millerRabin()\r\n// millerRabin() spends:\r\n// 99% of its time in calls to powMod_() (always with a base of 2)\r\n// powMod_() spends:\r\n// 94% of its time in calls to mont_() (almost always with x==y)\r\n//\r\n// This suggests there are several ways to speed up this library slightly:\r\n// - convert powMod_ to use a Montgomery form of k-ary window (or maybe a Montgomery form of sliding window)\r\n// -- this should especially focus on being fast when raising 2 to a power mod n\r\n// - convert randTruePrime_() to use a minimum r of 1/3 instead of 1/2 with the appropriate change to the test\r\n// - tune the parameters in randTruePrime_(), including c, m, and recLimit\r\n// - speed up the single loop in mont_() that takes 95% of the runtime, perhaps by reducing checking\r\n// within the loop when all the parameters are the same length.\r\n//\r\n// There are several ideas that look like they wouldn't help much at all:\r\n// - replacing trial division in randTruePrime_() with a sieve (that speeds up something taking almost no time anyway)\r\n// - increase bpe from 15 to 30 (that would help if we had a 32*32->64 multiplier, but not with JavaScript's 32*32->32)\r\n// - speeding up mont_(x,y,n,np) when x==y by doing a non-modular, non-Montgomery square\r\n// followed by a Montgomery reduction. The intermediate answer will be twice as long as x, so that\r\n// method would be slower. This is unfortunate because the code currently spends almost all of its time\r\n// doing mont_(x,x,...), both for randTruePrime_() and powMod_(). A faster method for Montgomery squaring\r\n// would have a large impact on the speed of randTruePrime_() and powMod_(). HAC has a couple of poorly-worded\r\n// sentences that seem to imply it's faster to do a non-modular square followed by a single\r\n// Montgomery reduction, but that's obviously wrong.\r\n////////////////////////////////////////////////////////////////////////////////////////\r\n\r\n//globals\r\nexport var bpe=0; //bits stored per array element\r\nvar mask=0; //AND this with an array element to chop it down to bpe bits\r\nvar radix=mask+1; //equals 2^bpe. A single 1 bit to the left of the last bit of mask.\r\n\r\n//the digits for converting to different bases\r\nvar digitsStr='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_=!@#$%^&*()[]{}|;:,.<>/?`~ \\\\\\'\\\"+-';\r\n\r\n//initialize the global variables\r\nfor (bpe=0; (1<<(bpe+1)) > (1<<bpe); bpe++); //bpe=number of bits in the mantissa on this platform\r\nbpe>>=1; //bpe=number of bits in one element of the array representing the bigInt\r\nmask=(1<<bpe)-1; //AND the mask with an integer to get its bpe least significant bits\r\nradix=mask+1; //2^bpe. a single 1 bit to the left of the first bit of mask\r\nexport var one=int2bigInt(1,1,1); //constant used in powMod_()\r\n\r\n//the following global variables are scratchpad memory to\r\n//reduce dynamic memory allocation in the inner loop\r\nvar t=new Array(0);\r\nvar ss=t; //used in mult_()\r\nvar s0=t; //used in multMod_(), squareMod_()\r\nvar s1=t; //used in powMod_(), multMod_(), squareMod_()\r\nvar s2=t; //used in powMod_(), multMod_()\r\nvar s3=t; //used in powMod_()\r\nvar s4=t, s5=t; //used in mod_()\r\nvar s6=t; //used in bigInt2str()\r\nvar s7=t; //used in powMod_()\r\nvar T=t; //used in GCD_()\r\nvar sa=t; //used in mont_()\r\nvar mr_x1=t, mr_r=t, mr_a=t, //used in millerRabin()\r\neg_v=t, eg_u=t, eg_A=t, eg_B=t, eg_C=t, eg_D=t, //used in eGCD_(), inverseMod_()\r\nmd_q1=t, md_q2=t, md_q3=t, md_r=t, md_r1=t, md_r2=t, md_tt=t, //used in mod_()\r\n\r\nprimes=t, pows=t, s_i=t, s_i2=t, s_R=t, s_rm=t, s_q=t, s_n1=t,\r\n s_a=t, s_r2=t, s_n=t, s_b=t, s_d=t, s_x1=t, s_x2=t, s_aa=t, //used in randTruePrime_()\r\n\r\nrpprb=t; //used in randProbPrimeRounds() (which also uses \"primes\")\r\n\r\n////////////////////////////////////////////////////////////////////////////////////////\r\n\r\nvar k, buff\r\n\r\n//return array of all primes less than integer n\r\nfunction findPrimes(n) {\r\n var i,s,p,ans;\r\n s=new Array(n);\r\n for (i=0;i<n;i++)\r\n s[i]=0;\r\n s[0]=2;\r\n p=0; //first p elements of s are primes, the rest are a sieve\r\n for(;s[p]<n;) { //s[p] is the pth prime\r\n for(i=s[p]*s[p]; i<n; i+=s[p]) //mark multiples of s[p]\r\n s[i]=1;\r\n p++;\r\n s[p]=s[p-1]+1;\r\n for(; s[p]<n && s[s[p]]; s[p]++); //find next prime (where s[p]==0)\r\n }\r\n ans=new Array(p);\r\n for(i=0;i<p;i++)\r\n ans[i]=s[i];\r\n return ans;\r\n}\r\n\r\n\r\n//does a single round of Miller-Rabin base b consider x to be a possible prime?\r\n//x is a bigInt, and b is an integer, with b<x\r\nfunction millerRabinInt(x,b) {\r\n if (mr_x1.length!=x.length) {\r\n mr_x1=dup(x);\r\n mr_r=dup(x);\r\n mr_a=dup(x);\r\n }\r\n\r\n copyInt_(mr_a,b);\r\n return millerRabin(x,mr_a);\r\n}\r\n\r\n//does a single round of Miller-Rabin base b consider x to be a possible prime?\r\n//x and b are bigInts with b<x\r\nfunction millerRabin(x,b) {\r\n var i,j,k,s;\r\n\r\n if (mr_x1.length!=x.length) {\r\n mr_x1=dup(x);\r\n mr_r=dup(x);\r\n mr_a=dup(x);\r\n }\r\n\r\n copy_(mr_a,b);\r\n copy_(mr_r,x);\r\n copy_(mr_x1,x);\r\n\r\n addInt_(mr_r,-1);\r\n addInt_(mr_x1,-1);\r\n\r\n //s=the highest power of two that divides mr_r\r\n k=0;\r\n for (i=0;i<mr_r.length;i++)\r\n for (j=1;j<mask;j<<=1)\r\n if (x[i] & j) {\r\n s=(k<mr_r.length+bpe ? k : 0);\r\n i=mr_r.length;\r\n j=mask;\r\n } else\r\n k++;\r\n\r\n if (s)\r\n rightShift_(mr_r,s);\r\n\r\n powMod_(mr_a,mr_r,x);\r\n\r\n if (!equalsInt(mr_a,1) && !equals(mr_a,mr_x1)) {\r\n j=1;\r\n while (j<=s-1 && !equals(mr_a,mr_x1)) {\r\n squareMod_(mr_a,x);\r\n if (equalsInt(mr_a,1)) {\r\n return 0;\r\n }\r\n j++;\r\n }\r\n if (!equals(mr_a,mr_x1)) {\r\n return 0;\r\n }\r\n }\r\n return 1;\r\n}\r\n\r\n//returns how many bits long the bigInt is, not counting leading zeros.\r\nfunction bitSize(x) {\r\n var j,z,w;\r\n for (j=x.length-1; (x[j]==0) && (j>0); j--);\r\n for (z=0,w=x[j]; w; (w>>=1),z++);\r\n z+=bpe*j;\r\n return z;\r\n}\r\n\r\n//return a copy of x with at least n elements, adding leading zeros if needed\r\nfunction expand(x,n) {\r\n var ans=int2bigInt(0,(x.length>n ? x.length : n)*bpe,0);\r\n copy_(ans,x);\r\n return ans;\r\n}\r\n\r\n//return a k-bit true random prime using Maurer's algorithm.\r\nfunction randTruePrime(k) {\r\n var ans=int2bigInt(0,k,0);\r\n randTruePrime_(ans,k);\r\n return trim(ans,1);\r\n}\r\n\r\n//return a k-bit random probable prime with probability of error < 2^-80\r\nfunction randProbPrime(k) {\r\n if (k>=600) return randProbPrimeRounds(k,2); //numbers from HAC table 4.3\r\n if (k>=550) return randProbPrimeRounds(k,4);\r\n if (k>=500) return randProbPrimeRounds(k,5);\r\n if (k>=400) return randProbPrimeRounds(k,6);\r\n if (k>=350) return randProbPrimeRounds(k,7);\r\n if (k>=300) return randProbPrimeRounds(k,9);\r\n if (k>=250) return randProbPrimeRounds(k,12); //numbers from HAC table 4.4\r\n if (k>=200) return randProbPrimeRounds(k,15);\r\n if (k>=150) return randProbPrimeRounds(k,18);\r\n if (k>=100) return randProbPrimeRounds(k,27);\r\n return randProbPrimeRounds(k,40); //number from HAC remark 4.26 (only an estimate)\r\n}\r\n\r\n//return a k-bit probable random prime using n rounds of Miller Rabin (after trial division with small primes)\r\nfunction randProbPrimeRounds(k,n) {\r\n var ans, i, divisible, B;\r\n B=30000; //B is largest prime to use in trial division\r\n ans=int2bigInt(0,k,0);\r\n\r\n //optimization: try larger and smaller B to find the best limit.\r\n\r\n if (primes.length==0)\r\n primes=findPrimes(30000); //check for divisibility by primes <=30000\r\n\r\n if (rpprb.length!=ans.length)\r\n rpprb=dup(ans);\r\n\r\n for (;;) { //keep trying random values for ans until one appears to be prime\r\n //optimization: pick a random number times L=2*3*5*...*p, plus a\r\n // random element of the list of all numbers in [0,L) not divisible by any prime up to p.\r\n // This can reduce the amount of random number generation.\r\n\r\n randBigInt_(ans,k,0); //ans = a random odd number to check\r\n ans[0] |= 1;\r\n divisible=0;\r\n\r\n //check ans for divisibility by small primes up to B\r\n for (i=0; (i<primes.length) && (primes[i]<=B); i++)\r\n if (modInt(ans,primes[i])==0 && !equalsInt(ans,primes[i])) {\r\n divisible=1;\r\n break;\r\n }\r\n\r\n //optimization: change millerRabin so the base can be bigger than the number being checked, then eliminate the while here.\r\n\r\n //do n rounds of Miller Rabin, with random bases less than ans\r\n for (i=0; i<n && !divisible; i++) {\r\n randBigInt_(rpprb,k,0);\r\n while(!greater(ans,rpprb)) //pick a random rpprb that's < ans\r\n randBigInt_(rpprb,k,0);\r\n if (!millerRabin(ans,rpprb))\r\n divisible=1;\r\n }\r\n\r\n if(!divisible)\r\n return ans;\r\n }\r\n}\r\n\r\n//return a new bigInt equal to (x mod n) for bigInts x and n.\r\nfunction mod(x,n) {\r\n var ans=dup(x);\r\n mod_(ans,n);\r\n return trim(ans,1);\r\n}\r\n\r\n//return (x+n) where x is a bigInt and n is an integer.\r\nfunction addInt(x,n) {\r\n var ans=expand(x,x.length+1);\r\n addInt_(ans,n);\r\n return trim(ans,1);\r\n}\r\n\r\n//return x*y for bigInts x and y. This is faster when y<x.\r\nfunction mult(x,y) {\r\n var ans=expand(x,x.length+y.length);\r\n mult_(ans,y);\r\n return trim(ans,1);\r\n}\r\n\r\n//return (x**y mod n) where x,y,n are bigInts and ** is exponentiation. 0**0=1. Faster for odd n.\r\nexport function powMod(x,y,n) {\r\n var ans=expand(x,n.length);\r\n powMod_(ans,trim(y,2),trim(n,2),0); //this should work without the trim, but doesn't\r\n return trim(ans,1);\r\n}\r\n\r\n//return (x-y) for bigInts x and y. Negative answers will be 2s complement\r\nfunction sub(x,y) {\r\n var ans=expand(x,(x.length>y.length ? x.length+1 : y.length+1));\r\n sub_(ans,y);\r\n return trim(ans,1);\r\n}\r\n\r\n//return (x+y) for bigInts x and y.\r\nfunction add(x,y) {\r\n var ans=expand(x,(x.length>y.length ? x.length+1 : y.length+1));\r\n add_(ans,y);\r\n return trim(ans,1);\r\n}\r\n\r\n//return (x**(-1) mod n) for bigInts x and n. If no inverse exists, it returns null\r\nfunction inverseMod(x,n) {\r\n var ans=expand(x,n.length);\r\n var s;\r\n s=inverseMod_(ans,n);\r\n return s ? trim(ans,1) : null;\r\n}\r\n\r\n//return (x*y mod n) for bigInts x,y,n. For greater speed, let y<x.\r\nfunction multMod(x,y,n) {\r\n var ans=expand(x,n.length);\r\n multMod_(ans,y,n);\r\n return trim(ans,1);\r\n}\r\n\r\n//generate a k-bit true random prime using Maurer's algorithm,\r\n//and put it into ans. The bigInt ans must be large enough to hold it.\r\nfunction randTruePrime_(ans,k) {\r\n var c,m,pm,dd,j,r,B,divisible,z,zz,recSize;\r\n\r\n if (primes.length==0)\r\n primes=findPrimes(30000); //check for divisibility by primes <=30000\r\n\r\n if (pows.length==0) {\r\n pows=new Array(512);\r\n for (j=0;j<512;j++) {\r\n pows[j]=Math.pow(2,j/511.-1.);\r\n }\r\n }\r\n\r\n //c and m should be tuned for a particular machine and value of k, to maximize speed\r\n c=0.1; //c=0.1 in HAC\r\n m=20; //generate this k-bit number by first recursively generating a number that has between k/2 and k-m bits\r\n recLimit=20; //stop recursion when k <=recLimit. Must have recLimit >= 2\r\n\r\n if (s_i2.length!=ans.length) {\r\n s_i2=dup(ans);\r\n s_R =dup(ans);\r\n s_n1=dup(ans);\r\n s_r2=dup(ans);\r\n s_d =dup(ans);\r\n s_x1=dup(ans);\r\n s_x2=dup(ans);\r\n s_b =dup(ans);\r\n s_n =dup(ans);\r\n s_i =dup(ans);\r\n s_rm=dup(ans);\r\n s_q =dup(ans);\r\n s_a =dup(ans);\r\n s_aa=dup(ans);\r\n }\r\n\r\n if (k <= recLimit) { //generate small random primes by trial division up to its square root\r\n pm=(1<<((k+2)>>1))-1; //pm is binary number with all ones, just over sqrt(2^k)\r\n copyInt_(ans,0);\r\n for (dd=1;dd;) {\r\n dd=0;\r\n ans[0]= 1 | (1<<(k-1)) | Math.floor(Math.random()*(1<<k)); //random, k-bit, odd integer, with msb 1\r\n for (j=1;(j<primes.length) && ((primes[j]&pm)==primes[j]);j++) { //trial division by all primes 3...sqrt(2^k)\r\n if (0==(ans[0]%primes[j])) {\r\n dd=1;\r\n break;\r\n }\r\n }\r\n }\r\n carry_(ans);\r\n return;\r\n }\r\n\r\n B=c*k*k; //try small primes up to B (or all the primes[] array if the largest is less than B).\r\n if (k>2*m) //generate this k-bit number by first recursively generating a number that has between k/2 and k-m bits\r\n for (r=1; k-k*r<=m; )\r\n r=pows[Math.floor(Math.random()*512)]; //r=Math.pow(2,Math.random()-1);\r\n else\r\n r=.5;\r\n\r\n //simulation suggests the more complex algorithm using r=.333 is only slightly faster.\r\n\r\n recSize=Math.floor(r*k)+1;\r\n\r\n randTruePrime_(s_q,recSize);\r\n copyInt_(s_i2,0);\r\n s_i2[Math.floor((k-2)/bpe)] |= (1<<((k-2)%bpe)); //s_i2=2^(k-2)\r\n divide_(s_i2,s_q,s_i,s_rm); //s_i=floor((2^(k-1))/(2q))\r\n\r\n z=bitSize(s_i);\r\n\r\n for (;;) {\r\n for (;;) { //generate z-bit numbers until one falls in the range [0,s_i-1]\r\n randBigInt_(s_R,z,0);\r\n if (greater(s_i,s_R))\r\n break;\r\n } //now s_R is in the range [0,s_i-1]\r\n addInt_(s_R,1); //now s_R is in the range [1,s_i]\r\n add_(s_R,s_i); //now s_R is in the range [s_i+1,2*s_i]\r\n\r\n copy_(s_n,s_q);\r\n mult_(s_n,s_R);\r\n multInt_(s_n,2);\r\n addInt_(s_n,1); //s_n=2*s_R*s_q+1\r\n\r\n copy_(s_r2,s_R);\r\n multInt_(s_r2,2); //s_r2=2*s_R\r\n\r\n //check s_n for divisibility by small primes up to B\r\n for (divisible=0,j=0; (j<primes.length) && (primes[j]<B); j++)\r\n if (modInt(s_n,primes[j])==0 && !equalsInt(s_n,primes[j])) {\r\n divisible=1;\r\n break;\r\n }\r\n\r\n if (!divisible) //if it passes small primes check, then try a single Miller-Rabin base 2\r\n if (!millerRabinInt(s_n,2)) //this line represents 75% of the total runtime for randTruePrime_\r\n divisible=1;\r\n\r\n if (!divisible) { //if it passes that test, continue checking s_n\r\n addInt_(s_n,-3);\r\n for (j=s_n.length-1;(s_n[j]==0) && (j>0); j--); //strip leading zeros\r\n for (zz=0,w=s_n[j]; w; (w>>=1),zz++);\r\n zz+=bpe*j; //zz=number of bits in s_n, ignoring leading zeros\r\n for (;;) { //generate z-bit numbers until one falls in the range [0,s_n-1]\r\n randBigInt_(s_a,zz,0);\r\n if (greater(s_n,s_a))\r\n break;\r\n } //now s_a is in the range [0,s_n-1]\r\n addInt_(s_n,3); //now s_a is in the range [0,s_n-4]\r\n addInt_(s_a,2); //now s_a is in the range [2,s_n-2]\r\n copy_(s_b,s_a);\r\n copy_(s_n1,s_n);\r\n addInt_(s_n1,-1);\r\n powMod_(s_b,s_n1,s_n); //s_b=s_a^(s_n-1) modulo s_n\r\n addInt_(s_b,-1);\r\n if (isZero(s_b)) {\r\n copy_(s_b,s_a);\r\n powMod_(s_b,s_r2,s_n);\r\n addInt_(s_b,-1);\r\n copy_(s_aa,s_n);\r\n copy_(s_d,s_b);\r\n GCD_(s_d,s_n); //if s_b and s_n are relatively prime, then s_n is a prime\r\n if (equalsInt(s_d,1)) {\r\n copy_(ans,s_aa);\r\n return; //if we've made it this far, then s_n is absolutely guaranteed to be prime\r\n }\r\n }\r\n }\r\n }\r\n}\r\n\r\n//Return an n-bit random BigInt (n>=1). If s=1, then the most significant of those n bits is set to 1.\r\nfunction randBigInt(n,s) {\r\n var a,b;\r\n a=Math.floor((n-1)/bpe)+2; //# array elements to hold the BigInt with a leading 0 element\r\n b=int2bigInt(0,0,a);\r\n randBigInt_(b,n,s);\r\n return b;\r\n}\r\n\r\n//Set b to an n-bit random BigInt. If s=1, then the most significant of those n bits is set to 1.\r\n//Array b must be big enough to hold the result. Must have n>=1\r\nfunction randBigInt_(b,n,s) {\r\n var i,a;\r\n for (i=0;i<b.length;i++)\r\n b[i]=0;\r\n a=Math.floor((n-1)/bpe)+1; //# array elements to hold the BigInt\r\n for (i=0;i<a;i++) {\r\n b[i]=Math.floor(Math.random()*(1<<(bpe-1)));\r\n }\r\n b[a-1] &= (2<<((n-1)%bpe))-1;\r\n if (s==1)\r\n b[a-1] |= (1<<((n-1)%bpe));\r\n}\r\n\r\n//Return the greatest common divisor of bigInts x and y (each with same number of elements).\r\nfunction GCD(x,y) {\r\n var xc,yc;\r\n xc=dup(x);\r\n yc=dup(y);\r\n GCD_(xc,yc);\r\n return xc;\r\n}\r\n\r\n//set x to the greatest common divisor of bigInts x and y (each with same number of elements).\r\n//y is destroyed.\r\nfunction GCD_(x,y) {\r\n var i,xp,yp,A,B,C,D,q,sing;\r\n if (T.length!=x.length)\r\n T=dup(x);\r\n\r\n sing=1;\r\n while (sing) { //while y has nonzero elements other than y[0]\r\n sing=0;\r\n for (i=1;i<y.length;i++) //check if y has nonzero elements other than 0\r\n if (y[i]) {\r\n sing=1;\r\n break;\r\n }\r\n if (!sing) break; //quit when y all zero elements except possibly y[0]\r\n\r\n for (i=x.length;!x[i] && i>=0;i--); //find most significant element of x\r\n xp=x[i];\r\n yp=y[i];\r\n A=1; B=0; C=0; D=1;\r\n while ((yp+C) && (yp+D)) {\r\n q =Math.floor((xp+A)/(yp+C));\r\n qp=Math.floor((xp+B)/(yp+D));\r\n if (q!=qp)\r\n break;\r\n t= A-q*C; A=C; C=t; // do (A,B,xp, C,D,yp) = (C,D,yp, A,B,xp) - q*(0,0,0, C,D,yp)\r\n t= B-q*D; B=D; D=t;\r\n t=xp-q*yp; xp=yp; yp=t;\r\n }\r\n if (B) {\r\n copy_(T,x);\r\n linComb_(x,y,A,B); //x=A*x+B*y\r\n linComb_(y,T,D,C); //y=D*y+C*T\r\n } else {\r\n mod_(x,y);\r\n copy_(T,x);\r\n copy_(x,y);\r\n copy_(y,T);\r\n }\r\n }\r\n if (y[0]==0)\r\n return;\r\n t=modInt(x,y[0]);\r\n copyInt_(x,y[0]);\r\n y[0]=t;\r\n while (y[0]) {\r\n x[0]%=y[0];\r\n t=x[0]; x[0]=y[0]; y[0]=t;\r\n }\r\n}\r\n\r\n//do x=x**(-1) mod n, for bigInts x and n.\r\n//If no inverse exists, it sets x to zero and returns 0, else it returns 1.\r\n//The x array must be at least as large as the n array.\r\nfunction inverseMod_(x,n) {\r\n var k=1+2*Math.max(x.length,n.length);\r\n\r\n if(!(x[0]&1) && !(n[0]&1)) { //if both inputs are even, then inverse doesn't exist\r\n copyInt_(x,0);\r\n return 0;\r\n }\r\n\r\n if (eg_u.length!=k) {\r\n eg_u=new Array(k);\r\n eg_v=new Array(k);\r\n eg_A=new Array(k);\r\n eg_B=new Array(k);\r\n eg_C=new Array(k);\r\n eg_D=new Array(k);\r\n }\r\n\r\n copy_(eg_u,x);\r\n copy_(eg_v,n);\r\n copyInt_(eg_A,1);\r\n copyInt_(eg_B,0);\r\n copyInt_(eg_C,0);\r\n copyInt_(eg_D,1);\r\n for (;;) {\r\n while(!(eg_u[0]&1)) { //while eg_u is even\r\n halve_(eg_u);\r\n if (!(eg_A[0]&1) && !(eg_B[0]&1)) { //if eg_A==eg_B==0 mod 2\r\n halve_(eg_A);\r\n halve_(eg_B);\r\n } else {\r\n add_(eg_A,n); halve_(eg_A);\r\n sub_(eg_B,x); halve_(eg_B);\r\n }\r\n }\r\n\r\n while (!(eg_v[0]&1)) { //while eg_v is even\r\n halve_(eg_v);\r\n if (!(eg_C[0]&1) && !(eg_D[0]&1)) { //if eg_C==eg_D==0 mod 2\r\n halve_(eg_C);\r\n halve_(eg_D);\r\n } else {\r\n add_(eg_C,n); halve_(eg_C);\r\n sub_(eg_D,x); halve_(eg_D);\r\n }\r\n }\r\n\r\n if (!greater(eg_v,eg_u)) { //eg_v <= eg_u\r\n sub_(eg_u,eg_v);\r\n sub_(eg_A,eg_C);\r\n sub_(eg_B,eg_D);\r\n } else { //eg_v > eg_u\r\n sub_(eg_v,eg_u);\r\n sub_(eg_C,eg_A);\r\n sub_(eg_D,eg_B);\r\n }\r\n\r\n if (equalsInt(eg_u,0)) {\r\n while (negative(eg_C)) //make sure answer is nonnegative\r\n add_(eg_C,n);\r\n copy_(x,eg_C);\r\n\r\n if (!equalsInt(eg_v,1)) { //if GCD_(x,n)!=1, then there is no inverse\r\n copyInt_(x,0);\r\n return 0;\r\n }\r\n return 1;\r\n }\r\n }\r\n}\r\n\r\n//return x**(-1) mod n, for integers x and n. Return 0 if there is no inverse\r\nfunction inverseModInt(x,n) {\r\n var a=1,b=0,t;\r\n for (;;) {\r\n if (x==1) return a;\r\n if (x==0) return 0;\r\n b-=a*Math.floor(n/x);\r\n n%=x;\r\n\r\n if (n==1) return b; //to avoid negatives, change this b to n-b, and each -= to +=\r\n if (n==0) return 0;\r\n a-=b*Math.floor(x/n);\r\n x%=n;\r\n }\r\n}\r\n\r\n//this deprecated function is for backward compatibility only.\r\nfunction inverseModInt_(x,n) {\r\n return inverseModInt(x,n);\r\n}\r\n\r\n\r\n//Given positive bigInts x and y, change the bigints v, a, and b to positive bigInts such that:\r\n// v = GCD_(x,y) = a*x-b*y\r\n//The bigInts v, a, b, must have exactly as many elements as the larger of x and y.\r\nexport function eGCD_(x,y,v,a,b) {\r\n var g=0;\r\n var k=Math.max(x.length,y.length);\r\n if (eg_u.length!=k) {\r\n eg_u=new Array(k);\r\n eg_A=new Array(k);\r\n eg_B=new Array(k);\r\n eg_C=new Array(k);\r\n eg_D=new Array(k);\r\n }\r\n while(!(x[0]&1) && !(y[0]&1)) { //while x and y both even\r\n halve_(x);\r\n halve_(y);\r\n g++;\r\n }\r\n copy_(eg_u,x);\r\n copy_(v,y);\r\n copyInt_(eg_A,1);\r\n copyInt_(eg_B,0);\r\n copyInt_(eg_C,0);\r\n copyInt_(eg_D,1);\r\n for (;;) {\r\n while(!(eg_u[0]&1)) { //while u is even\r\n halve_(eg_u);\r\n if (!(eg_A[0]&1) && !(eg_B[0]&1)) { //if A==B==0 mod 2\r\n halve_(eg_A);\r\n halve_(eg_B);\r\n } else {\r\n add_(eg_A,y); halve_(eg_A);\r\n sub_(eg_B,x); halve_(eg_B);\r\n }\r\n }\r\n\r\n while (!(v[0]&1)) { //while v is even\r\n halve_(v);\r\n if (!(eg_C[0]&1) && !(eg_D[0]&1)) { //if C==D==0 mod 2\r\n halve_(eg_C);\r\n halve_(eg_D);\r\n } else {\r\n add_(eg_C,y); halve_(eg_C);\r\n sub_(eg_D,x); halve_(eg_D);\r\n }\r\n }\r\n\r\n if (!greater(v,eg_u)) { //v<=u\r\n sub_(eg_u,v);\r\n sub_(eg_A,eg_C);\r\n sub_(eg_B,eg_D);\r\n } else { //v>u\r\n sub_(v,eg_u);\r\n sub_(eg_C,eg_A);\r\n sub_(eg_D,eg_B);\r\n }\r\n if (equalsInt(eg_u,0)) {\r\n while (negative(eg_C)) { //make sure a (C) is nonnegative\r\n add_(eg_C,y);\r\n sub_(eg_D,x);\r\n }\r\n multInt_(eg_D,-1); ///make sure b (D) is nonnegative\r\n copy_(a,eg_C);\r\n copy_(b,eg_D);\r\n leftShift_(v,g);\r\n return;\r\n }\r\n }\r\n}\r\n\r\n\r\n//is bigInt x negative?\r\nfunction negative(x) {\r\n return ((x[x.length-1]>>(bpe-1))&1);\r\n}\r\n\r\n\r\n//is (x << (shift*bpe)) > y?\r\n//x and y are nonnegative bigInts\r\n//shift is a nonnegative integer\r\nfunction greaterShift(x,y,shift) {\r\n var i, kx=x.length, ky=y.length;\r\n k=((kx+shift)<ky) ? (kx+shift) : ky;\r\n for (i=ky-1-shift; i<kx && i>=0; i++)\r\n if (x[i]>0)\r\n return 1; //if there are nonzeros in x to the left of the first column of y, then x is bigger\r\n for (i=kx-1+shift; i<ky; i++)\r\n if (y[i]>0)\r\n return 0; //if there are nonzeros in y to the left of the first column of x, then x is not bigger\r\n for (i=k-1; i>=shift; i--)\r\n if (x[i-shift]>y[i]) return 1;\r\n else if (x[i-shift]<y[i]) return 0;\r\n return 0;\r\n}\r\n\r\n//is x > y? (x and y both nonnegative)\r\nexport function greater(x,y) {\r\n var i;\r\n var k=(x.length<y.length) ? x.length : y.length;\r\n\r\n for (i=x.length;i<y.length;i++)\r\n if (y[i])\r\n return 0; //y has more digits\r\n\r\n for (i=y.length;i<x.length;i++)\r\n if (x[i])\r\n return 1; //x has more digits\r\n\r\n for (i=k-1;i>=0;i--)\r\n if (x[i]>y[i])\r\n return 1;\r\n else if (x[i]<y[i])\r\n return 0;\r\n return 0;\r\n}\r\n\r\n//divide x by y giving quotient q and remainder r. (q=floor(x/y), r=x mod y). All 4 are bigints.\r\n//x must have at least one leading zero element.\r\n//y must be nonzero.\r\n//q and r must be arrays that are exactly the same length as x. (Or q can have more).\r\n//Must have x.length >= y.length >= 2.\r\nexport function divide_(x,y,q,r) {\r\n var kx, ky;\r\n var i,j,y1,y2,c,a,b;\r\n copy_(r,x);\r\n for (ky=y.length;y[ky-1]==0;ky--); //ky is number of elements in y, not including leading zeros\r\n\r\n //normalize: ensure the most significant element of y has its highest bit set\r\n b=y[ky-1];\r\n for (a=0; b; a++)\r\n b>>=1;\r\n a=bpe-a; //a is how many bits to shift so that the high order bit of y is leftmost in its array element\r\n leftShift_(y,a); //multiply both by 1<<a now, then divide both by that at the end\r\n leftShift_(r,a);\r\n\r\n //Rob Visser discovered a bug: the following line was originally just before the normalization.\r\n for (kx=r.length;r[kx-1]==0 && kx>ky;kx--); //kx is number of elements in normalized x, not including leading zeros\r\n\r\n copyInt_(q,0); // q=0\r\n while (!greaterShift(y,r,kx-ky)) { // while (leftShift_(y,kx-ky) <= r) {\r\n subShift_(r,y,kx-ky); // r=r-leftShift_(y,kx-ky)\r\n q[kx-ky]++; // q[kx-ky]++;\r\n } // }\r\n\r\n for (i=kx-1; i>=ky; i--) {\r\n if (r[i]==y[ky-1])\r\n q[i-ky]=mask;\r\n else\r\n q[i-ky]=Math.floor((r[i]*radix+r[i-1])/y[ky-1]);\r\n\r\n //The following for(;;) loop is equivalent to the commented while loop,\r\n //except that the uncommented version avoids overflow.\r\n //The commented loop comes from HAC, which assumes r[-1]==y[-1]==0\r\n // while (q[i-ky]*(y[ky-1]*radix+y[ky-2]) > r[i]*radix*radix+r[i-1]*radix+r[i-2])\r\n // q[i-ky]--;\r\n for (;;) {\r\n y2=(ky>1 ? y[ky-2] : 0)*q[i-ky];\r\n c=y2>>bpe;\r\n y2=y2 & mask;\r\n y1=c+q[i-ky]*y[ky-1];\r\n c=y1>>bpe;\r\n y1=y1 & mask;\r\n\r\n if (c==r[i] ? y1==r[i-1] ? y2>(i>1 ? r[i-2] : 0) : y1>r[i-1] : c>r[i])\r\n q[i-ky]--;\r\n else\r\n break;\r\n }\r\n\r\n linCombShift_(r,y,-q[i-ky],i-ky); //r=r-q[i-ky]*leftShift_(y,i-ky)\r\n if (negative(r)) {\r\n addShift_(r,y,i-ky); //r=r+leftShift_(y,i-ky)\r\n q[i-ky]--;\r\n }\r\n }\r\n\r\n rightShift_(y,a); //undo the normalization step\r\n rightShift_(r,a); //undo the normalization step\r\n}\r\n\r\n//do carries and borrows so each element of the bigInt x fits in bpe bits.\r\nfunction carry_(x) {\r\n var i,k,c,b;\r\n k=x.length;\r\n c=0;\r\n for (i=0;i<k;i++) {\r\n c+=x[i];\r\n b=0;\r\n if (c<0) {\r\n b=-(c>>bpe);\r\n c+=b*radix;\r\n }\r\n x[i]=c & mask;\r\n c=(c>>bpe)-b;\r\n }\r\n}\r\n\r\n//return x mod n for bigInt x and integer n.\r\nfunction modInt(x,n) {\r\n var i,c=0;\r\n for (i=x.length-1; i>=0; i--)\r\n c=(c*radix+x[i])%n;\r\n return c;\r\n}\r\n\r\n//convert the integer t into a bigInt with at least the given number of bits.\r\n//the returned array stores the bigInt in bpe-bit chunks, little endian (buff[0] is least significant word)\r\n//Pad the array with leading zeros so that it has at least minSize elements.\r\n//There will always be at least one leading 0 element.\r\nfunction int2bigInt(t,bits,minSize) {\r\n var i,k;\r\n k=Math.ceil(bits/bpe)+1;\r\n k=minSize>k ? minSize : k;\r\n var buff=new Array(k);\r\n copyInt_(buff,t);\r\n return buff;\r\n}\r\n\r\n//return the bigInt given a string representation in a given base.\r\n//Pad the array with leading zeros so that it has at least minSize elements.\r\n//If base=-1, then it reads in a space-separated list of array elements in decimal.\r\n//The array will always have at least one leading zero, unless base=-1.\r\nexport function str2bigInt(s,base,minSize) {\r\n var d, i, j, x, y, kk;\r\n var k=s.length;\r\n if (base==-1) { //comma-separated list of array elements in decimal\r\n x=new Array(0);\r\n for (;;) {\r\n y=new Array(x.length+1);\r\n for (i=0;i<x.length;i++)\r\n y[i+1]=x[i];\r\n y[0]=parseInt(s,10);\r\n x=y;\r\n d=s.indexOf(',',0);\r\n if (d<1)\r\n break;\r\n s=s.substring(d+1);\r\n if (s.length==0)\r\n break;\r\n }\r\n if (x.length<minSize) {\r\n y=new Array(minSize);\r\n copy_(y,x);\r\n return y;\r\n }\r\n return x;\r\n }\r\n\r\n x=int2bigInt(0,base*k,0);\r\n for (i=0;i<k;i++) {\r\n d=digitsStr.indexOf(s.substring(i,i+1),0);\r\n if (base<=36 && d>=36) //convert lowercase to uppercase if base<=36\r\n d-=26;\r\n if (d>=base || d<0) { //stop at first illegal character\r\n break;\r\n }\r\n multInt_(x,base);\r\n addInt_(x,d);\r\n }\r\n\r\n for (k=x.length;k>0 && !x[k-1];k--); //strip off leading zeros\r\n k=minSize>k+1 ? minSize : k+1;\r\n y=new Array(k);\r\n kk=k<x.length ? k : x.length;\r\n for (i=0;i<kk;i++)\r\n y[i]=x[i];\r\n for (;i<k;i++)\r\n y[i]=0;\r\n return y;\r\n}\r\n\r\n//is bigint x equal to integer y?\r\n//y must have less than bpe bits\r\nexport function equalsInt(x,y) {\r\n var i;\r\n if (x[0]!=y)\r\n return 0;\r\n for (i=1;i<x.length;i++)\r\n if (x[i])\r\n return 0;\r\n return 1;\r\n}\r\n\r\n//are bigints x and y equal?\r\n//this works even if x and y are different lengths and have arbitrarily many leading zeros\r\nfunction equals(x,y) {\r\n var i;\r\n var k=x.length<y.length ? x.length : y.length;\r\n for (i=0;i<k;i++)\r\n if (x[i]!=y[i])\r\n return 0;\r\n if (x.length>y.length) {\r\n for (;i<x.length;i++)\r\n if (x[i])\r\n return 0;\r\n } else {\r\n for (;i<y.length;i++)\r\n if (y[i])\r\n return 0;\r\n }\r\n return 1;\r\n}\r\n\r\n//is the bigInt x equal to zero?\r\nexport function isZero(x) {\r\n var i;\r\n for (i=0;i<x.length;i++)\r\n if (x[i])\r\n return 0;\r\n return 1;\r\n}\r\n\r\n//convert a bigInt into a string in a given base, from base 2 up to base 95.\r\n//Base -1 prints the contents of the array representing the number.\r\nexport function bigInt2str(x,base) {\r\n var i,t,s=\"\";\r\n\r\n if (s6.length!=x.length)\r\n s6=dup(x);\r\n else\r\n copy_(s6,x);\r\n\r\n if (base==-1) { //return the list of array contents\r\n for (i=x.length-1;i>0;i--)\r\n s+=x[i]+',';\r\n s+=x[0];\r\n }\r\n else { //return it in the given base\r\n while (!isZero(s6)) {\r\n t=divInt_(s6,base); //t=s6 % base; s6=floor(s6/base);\r\n s=digitsStr.substring(t,t+1)+s;\r\n }\r\n }\r\n if (s.length==0)\r\n s=\"0\";\r\n return s;\r\n}\r\n\r\n//returns a duplicate of bigInt x\r\nfunction dup(x) {\r\n var i;\r\n buff=new Array(x.length);\r\n copy_(buff,x);\r\n return buff;\r\n}\r\n\r\n//do x=y on bigInts x and y. x must be an array at least as big as y (not counting the leading zeros in y).\r\nexport function copy_(x,y) {\r\n var i;\r\n var k=x.length<y.length ? x.length : y.length;\r\n for (i=0;i<k;i++)\r\n x[i]=y[i];\r\n for (i=k;i<x.length;i++)\r\n x[i]=0;\r\n}\r\n\r\n//do x=y on bigInt x and integer y.\r\nexport function copyInt_(x,n) {\r\n var i,c;\r\n for (c=n,i=0;i<x.length;i++) {\r\n x[i]=c & mask;\r\n c>>=bpe;\r\n }\r\n}\r\n\r\n//do x=x+n where x is a bigInt and n is an integer.\r\n//x must be large enough to hold the result.\r\nfunction addInt_(x,n) {\r\n var i,k,c,b;\r\n x[0]+=n;\r\n k=x.length;\r\n c=0;\r\n for (i=0;i<k;i++) {\r\n c+=x[i];\r\n b=0;\r\n if (c<0) {\r\n b=-(c>>bpe);\r\n c+=b*radix;\r\n }\r\n x[i]=c & mask;\r\n c=(c>>bpe)-b;\r\n if (!c) return; //stop carrying as soon as the carry is zero\r\n }\r\n}\r\n\r\n//right shift bigInt x by n bits. 0 <= n < bpe.\r\nexport function rightShift_(x,n) {\r\n var i;\r\n var k=Math.floor(n/bpe);\r\n if (k) {\r\n for (i=0;i<x.length-k;i++) //right shift x by k elements\r\n x[i]=x[i+k];\r\n for (;i<x.length;i++)\r\n x[i]=0;\r\n n%=bpe;\r\n }\r\n for (i=0;i<x.length-1;i++) {\r\n x[i]=mask & ((x[i+1]<<(bpe-n)) | (x[i]>>n));\r\n }\r\n x[i]>>=n;\r\n}\r\n\r\n//do x=floor(|x|/2)*sgn(x) for bigInt x in 2's complement\r\nfunction halve_(x) {\r\n var i;\r\n for (i=0;i<x.length-1;i++) {\r\n x[i]=mask & ((x[i+1]<<(bpe-1)) | (x[i]>>1));\r\n }\r\n x[i]=(x[i]>>1) | (x[i] & (radix>>1)); //most significant bit stays the same\r\n}\r\n\r\n//left shift bigInt x by n bits.\r\nfunction leftShift_(x,n) {\r\n var i;\r\n var k=Math.floor(n/bpe);\r\n if (k) {\r\n for (i=x.length; i>=k; i--) //left shift x by k elements\r\n x[i]=x[i-k];\r\n for (;i>=0;i--)\r\n x[i]=0;\r\n n%=bpe;\r\n }\r\n if (!n)\r\n return;\r\n for (i=x.length-1;i>0;i--) {\r\n x[i]=mask & ((x[i]<<n) | (x[i-1]>>(bpe-n)));\r\n }\r\n x[i]=mask & (x[i]<<n);\r\n}\r\n\r\n//do x=x*n where x is a bigInt and n is an integer.\r\n//x must be large enough to hold the result.\r\nfunction multInt_(x,n) {\r\n var i,k,c,b;\r\n if (!n)\r\n return;\r\n k=x.length;\r\n c=0;\r\n for (i=0;i<k;i++) {\r\n c+=x[i]*n;\r\n b=0;\r\n if (c<0) {\r\n b=-(c>>bpe);\r\n c+=b*radix;\r\n }\r\n x[i]=c & mask;\r\n c=(c>>bpe)-b;\r\n }\r\n}\r\n\r\n//do x=floor(x/n) for bigInt x and integer n, and return the remainder\r\nfunction divInt_(x,n) {\r\n var i,r=0,s;\r\n for (i=x.length-1;i>=0;i--) {\r\n s=r*radix+x[i];\r\n x[i]=Math.floor(s/n);\r\n r=s%n;\r\n }\r\n return r;\r\n}\r\n\r\n//do the linear combination x=a*x+b*y for bigInts x and y, and integers a and b.\r\n//x must be large enough to hold the answer.\r\nfunction linComb_(x,y,a,b) {\r\n var i,c,k,kk;\r\n k=x.length<y.length ? x.length : y.length;\r\n kk=x.length;\r\n for (c=0,i=0;i<k;i++) {\r\n c+=a*x[i]+b*y[i];\r\n x[i]=c & mask;\r\n c>>=bpe;\r\n }\r\n for (i=k;i<kk;i++) {\r\n c+=a*x[i];\r\n x[i]=c & mask;\r\n c>>=bpe;\r\n }\r\n}\r\n\r\n//do the linear combination x=a*x+b*(y<<(ys*bpe)) for bigInts x and y, and integers a, b and ys.\r\n//x must be large enough to hold the answer.\r\nfunction linCombShift_(x,y,b,ys) {\r\n var i,c,k,kk;\r\n k=x.length<ys+y.length ? x.length : ys+y.length;\r\n kk=x.length;\r\n for (c=0,i=ys;i<k;i++) {\r\n c+=x[i]+b*y[i-ys];\r\n x[i]=c & mask;\r\n c>>=bpe;\r\n }\r\n for (i=k;c && i<kk;i++) {\r\n c+=x[i];\r\n x[i]=c & mask;\r\n c>>=bpe;\r\n }\r\n}\r\n\r\n//do x=x+(y<<(ys*bpe)) for bigInts x and y, and integers a,b and ys.\r\n//x must be large enough to hold the answer.\r\nfunction addShift_(x,y,ys) {\r\n var i,c,k,kk;\r\n k=x.length<ys+y.length ? x.length : ys+y.length;\r\n kk=x.length;\r\n for (c=0,i=ys;i<k;i++) {\r\n c+=x[i]+y[i-ys];\r\n x[i]=c & mask;\r\n c>>=bpe;\r\n }\r\n for (i=k;c && i<kk;i++) {\r\n c+=x[i];\r\n x[i]=c & mask;\r\n c>>=bpe;\r\n }\r\n}\r\n\r\n//do x=x-(y<<(ys*bpe)) for bigInts x and y, and integers a,b and ys.\r\n//x must be large enough to hold the answer.\r\nfunction subShift_(x,y,ys) {\r\n var i,c,k,kk;\r\n k=x.length<ys+y.length ? x.length : ys+y.length;\r\n kk=x.length;\r\n for (c=0,i=ys;i<k;i++) {\r\n c+=x[i]-y[i-ys];\r\n x[i]=c & mask;\r\n c>>=bpe;\r\n }\r\n for (i=k;c && i<kk;i++) {\r\n c+=x[i];\r\n x[i]=c & mask;\r\n c>>=bpe;\r\n }\r\n}\r\n\r\n//do x=x-y for bigInts x and y.\r\n//x must be large enough to hold the answer.\r\n//negative answers will be 2s complement\r\nexport function sub_(x,y) {\r\n var i,c,k,kk;\r\n k=x.length<y.length ? x.length : y.length;\r\n for (c=0,i=0;i<k;i++) {\r\n c+=x[i]-y[i];\r\n x[i]=c & mask;\r\n c>>=bpe;\r\n }\r\n for (i=k;c && i<x.length;i++) {\r\n c+=x[i];\r\n x[i]=c & mask;\r\n c>>=bpe;\r\n }\r\n}\r\n\r\n//do x=x+y for bigInts x and y.\r\n//x must be large enough to hold the answer.\r\nexport function add_(x,y) {\r\n var i,c,k,kk;\r\n k=x.length<y.length ? x.length : y.length;\r\n for (c=0,i=0;i<k;i++) {\r\n c+=x[i]+y[i];\r\n x[i]=c & mask;\r\n c>>=bpe;\r\n }\r\n for (i=k;c && i<x.length;i++) {\r\n c+=x[i];\r\n x[i]=c & mask;\r\n c>>=bpe;\r\n }\r\n}\r\n\r\n//do x=x*y for bigInts x and y. This is faster when y<x.\r\nfunction mult_(x,y) {\r\n var i;\r\n if (ss.length!=2*x.length)\r\n ss=new Array(2*x.length);\r\n copyInt_(ss,0);\r\n for (i=0;i<y.length;i++)\r\n if (y[i])\r\n linCombShift_(ss,x,y[i],i); //ss=1*ss+y[i]*(x<<(i*bpe))\r\n copy_(x,ss);\r\n}\r\n\r\n//do x=x mod n for bigInts x and n.\r\nfunction mod_(x,n) {\r\n if (s4.length!=x.length)\r\n s4=dup(x);\r\n else\r\n copy_(s4,x);\r\n if (s5.length!=x.length)\r\n s5=dup(x);\r\n divide_(s4,n,s5,x); //x = remainder of s4 / n\r\n}\r\n\r\n//do x=x*y mod n for bigInts x,y,n.\r\n//for greater speed, let y<x.\r\nfunction multMod_(x,y,n) {\r\n var i;\r\n if (s0.length!=2*x.length)\r\n s0=new Array(2*x.length);\r\n copyInt_(s0,0);\r\n for (i=0;i<y.length;i++)\r\n if (y[i])\r\n linCombShift_(s0,x,y[i],i); //s0=1*s0+y[i]*(x<<(i*bpe))\r\n mod_(s0,n);\r\n copy_(x,s0);\r\n}\r\n\r\n//do x=x*x mod n for bigInts x,n.\r\nfunction squareMod_(x,n) {\r\n var i,j,d,c,kx,kn,k;\r\n for (kx=x.length; kx>0 && !x[kx-1]; kx--); //ignore leading zeros in x\r\n k=kx>n.length ? 2*kx : 2*n.length; //k=# elements in the product, which is twice the elements in the larger of x and n\r\n if (s0.length!=k)\r\n s0=new Array(k);\r\n copyInt_(s0,0);\r\n for (i=0;i<kx;i++) {\r\n c=s0[2*i]+x[i]*x[i];\r\n s0[2*i]=c & mask;\r\n c>>=bpe;\r\n for (j=i+1;j<kx;j++) {\r\n c=s0[i+j]+2*x[i]*x[j]+c;\r\n s0[i+j]=(c & mask);\r\n c>>=bpe;\r\n }\r\n s0[i+kx]=c;\r\n }\r\n mod_(s0,n);\r\n copy_(x,s0);\r\n}\r\n\r\n//return x with exactly k leading zero elements\r\nfunction trim(x,k) {\r\n var i,y;\r\n for (i=x.length; i>0 && !x[i-1]; i--);\r\n y=new Array(i+k);\r\n copy_(y,x);\r\n return y;\r\n}\r\n\r\n//do x=x**y mod n, where x,y,n are bigInts and ** is exponentiation. 0**0=1.\r\n//this is faster when n is odd. x usually needs to have as many elements as n.\r\nfunction powMod_(x,y,n) {\r\n var k1,k2,kn,np;\r\n if(s7.length!=n.length)\r\n s7=dup(n);\r\n\r\n //for even modulus, use a simple square-and-multiply algorithm,\r\n //rather than using the more complex Montgomery algorithm.\r\n if ((n[0]&1)==0) {\r\n copy_(s7,x);\r\n copyInt_(x,1);\r\n while(!equalsInt(y,0)) {\r\n if (y[0]&1)\r\n multMod_(x,s7,n);\r\n divInt_(y,2);\r\n squareMod_(s7,n);\r\n }\r\n return;\r\n }\r\n\r\n //calculate np from n for the Montgomery multiplications\r\n copyInt_(s7,0);\r\n for (kn=n.length;kn>0 && !n[kn-1];kn--);\r\n np=radix-inverseModInt(modInt(n,radix),radix);\r\n s7[kn]=1;\r\n multMod_(x ,s7,n); // x = x * 2**(kn*bp) mod n\r\n\r\n if (s3.length!=x.length)\r\n s3=dup(x);\r\n else\r\n copy_(s3,x);\r\n\r\n for (k1=y.length-1;k1>0 & !y[k1]; k1--); //k1=first nonzero element of y\r\n if (y[k1]==0) { //anything to the 0th power is 1\r\n copyInt_(x,1);\r\n return;\r\n }\r\n for (k2=1<<(bpe-1);k2 && !(y[k1] & k2); k2>>=1); //k2=position of first 1 bit in y[k1]\r\n for (;;) {\r\n if (!(k2>>=1)) { //look at next bit of y\r\n k1--;\r\n if (k1<0) {\r\n mont_(x,one,n,np);\r\n return;\r\n }\r\n k2=1<<(bpe-1);\r\n }\r\n mont_(x,x,n,np);\r\n\r\n if (k2 & y[k1]) //if next bit is a 1\r\n mont_(x,s3,n,np);\r\n }\r\n}\r\n\r\n\r\n//do x=x*y*Ri mod n for bigInts x,y,n,\r\n// where Ri = 2**(-kn*bpe) mod n, and kn is the\r\n// number of elements in the n array, not\r\n// counting leading zeros.\r\n//x array must have at least as many elemnts as the n array\r\n//It's OK if x and y are the same variable.\r\n//must have:\r\n// x,y < n\r\n// n is odd\r\n// np = -(n^(-1)) mod radix\r\nfunction mont_(x,y,n,np) {\r\n var i,j,c,ui,t,ks;\r\n var kn=n.length;\r\n var ky=y.length;\r\n\r\n if (sa.length!=kn)\r\n sa=new Array(kn);\r\n\r\n copyInt_(sa,0);\r\n\r\n for (;kn>0 && n[kn-1]==0;kn--); //ignore leading zeros of n\r\n for (;ky>0 && y[ky-1]==0;ky--); //ignore leading zeros of y\r\n ks=sa.length-1; //sa will never have more than this many nonzero elements.\r\n\r\n //the following loop consumes 95% of the runtime for randTruePrime_() and powMod_() for large numbers\r\n for (i=0; i<kn; i++) {\r\n t=sa[0]+x[i]*y[0];\r\n ui=((t & mask) * np) & mask; //the inner \"& mask\" was needed on Safari (but not MSIE) at one time\r\n c=(t+ui*n[0]) >> bpe;\r\n t=x[i];\r\n\r\n //do sa=(sa+x[i]*y+ui*n)/b where b=2**bpe. Loop is unrolled 5-fold for speed\r\n j=1;\r\n for (;j<ky-4;) { c+=sa[j]+ui*n[j]+t*y[j]; sa[j-1]=c & mask; c>>=bpe; j++;\r\n c+=sa[j]+ui*n[j]+t*y[j]; sa[j-1]=c & mask; c>>=bpe; j++;\r\n c+=sa[j]+ui*n[j]+t*y[j]; sa[j-1]=c & mask; c>>=bpe; j++;\r\n c+=sa[j]+ui*n[j]+t*y[j]; sa[j-1]=c & mask; c>>=bpe; j++;\r\n c+=sa[j]+ui*n[j]+t*y[j]; sa[j-1]=c & mask; c>>=bpe; j++; }\r\n for (;j<ky;) { c+=sa[j]+ui*n[j]+t*y[j]; sa[j-1]=c & mask; c>>=bpe; j++; }\r\n for (;j<kn-4;) { c+=sa[j]+ui*n[j]; sa[j-1]=c & mask; c>>=bpe; j++;\r\n c+=sa[j]+ui*n[j]; sa[j-1]=c & mask; c>>=bpe; j++;\r\n c+=sa[j]+ui*n[j]; sa[j-1]=c & mask; c>>=bpe; j++;\r\n c+=sa[j]+ui*n[j]; sa[j-1]=c & mask; c>>=bpe; j++;\r\n c+=sa[j]+ui*n[j]; sa[j-1]=c & mask; c>>=bpe; j++; }\r\n for (;j<kn;) { c+=sa[j]+ui*n[j]; sa[j-1]=c & mask; c>>=bpe; j++; }\r\n for (;j<ks;) { c+=sa[j]; sa[j-1]=c & mask; c>>=bpe; j++; }\r\n sa[j-1]=c & mask;\r\n }\r\n\r\n if (!greater(n,sa))\r\n sub_(sa,n);\r\n copy_(x,sa);\r\n}\r\n\r\n\n\n\n// WEBPACK FOOTER //\n// ./leemon.js","(function(){\n\n // Copyright (c) 2005 Tom Wu\n // All Rights Reserved.\n // See \"LICENSE\" for details.\n\n // Basic JavaScript BN library - subset useful for RSA encryption.\n\n // Bits per digit\n var dbits;\n\n // JavaScript engine analysis\n var canary = 0xdeadbeefcafe;\n var j_lm = ((canary&0xffffff)==0xefcafe);\n\n // (public) Constructor\n function BigInteger(a,b,c) {\n if(a != null)\n if(\"number\" == typeof a) this.fromNumber(a,b,c);\n else if(b == null && \"string\" != typeof a) this.fromString(a,256);\n else this.fromString(a,b);\n }\n\n // return new, unset BigInteger\n function nbi() { return new BigInteger(null); }\n\n // am: Compute w_j += (x*this_i), propagate carries,\n // c is initial carry, returns final carry.\n // c < 3*dvalue, x < 2*dvalue, this_i < dvalue\n // We need to select the fastest one that works in this environment.\n\n // am1: use a single mult and divide to get the high bits,\n // max digit bits should be 26 because\n // max internal value = 2*dvalue^2-2*dvalue (< 2^53)\n function am1(i,x,w,j,c,n) {\n while(--n >= 0) {\n var v = x*this[i++]+w[j]+c;\n c = Math.floor(v/0x4000000);\n w[j++] = v&0x3ffffff;\n }\n return c;\n }\n // am2 avoids a big mult-and-extract completely.\n // Max digit bits should be <= 30 because we do bitwise ops\n // on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)\n function am2(i,x,w,j,c,n) {\n var xl = x&0x7fff, xh = x>>15;\n while(--n >= 0) {\n var l = this[i]&0x7fff;\n var h = this[i++]>>15;\n var m = xh*l+h*xl;\n l = xl*l+((m&0x7fff)<<15)+w[j]+(c&0x3fffffff);\n c = (l>>>30)+(m>>>15)+xh*h+(c>>>30);\n w[j++] = l&0x3fffffff;\n }\n return c;\n }\n // Alternately, set max digit bits to 28 since some\n // browsers slow down when dealing with 32-bit numbers.\n function am3(i,x,w,j,c,n) {\n var xl = x&0x3fff, xh = x>>14;\n while(--n >= 0) {\n var l = this[i]&0x3fff;\n var h = this[i++]>>14;\n var m = xh*l+h*xl;\n l = xl*l+((m&0x3fff)<<14)+w[j]+c;\n c = (l>>28)+(m>>14)+xh*h;\n w[j++] = l&0xfffffff;\n }\n return c;\n }\n var inBrowser = typeof navigator !== \"undefined\";\n if(inBrowser && j_lm && (navigator.appName == \"Microsoft Internet Explorer\")) {\n BigInteger.prototype.am = am2;\n dbits = 30;\n }\n else if(inBrowser && j_lm && (navigator.appName != \"Netscape\")) {\n BigInteger.prototype.am = am1;\n dbits = 26;\n }\n else { // Mozilla/Netscape seems to prefer am3\n BigInteger.prototype.am = am3;\n dbits = 28;\n }\n\n BigInteger.prototype.DB = dbits;\n BigInteger.prototype.DM = ((1<<dbits)-1);\n BigInteger.prototype.DV = (1<<dbits);\n\n var BI_FP = 52;\n BigInteger.prototype.FV = Math.pow(2,BI_FP);\n BigInteger.prototype.F1 = BI_FP-dbits;\n BigInteger.prototype.F2 = 2*dbits-BI_FP;\n\n // Digit conversions\n var BI_RM = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n var BI_RC = new Array();\n var rr,vv;\n rr = \"0\".charCodeAt(0);\n for(vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv;\n rr = \"a\".charCodeAt(0);\n for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;\n rr = \"A\".charCodeAt(0);\n for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;\n\n function int2char(n) { return BI_RM.charAt(n); }\n function intAt(s,i) {\n var c = BI_RC[s.charCodeAt(i)];\n return (c==null)?-1:c;\n }\n\n // (protected) copy this to r\n function bnpCopyTo(r) {\n for(var i = this.t-1; i >= 0; --i) r[i] = this[i];\n r.t = this.t;\n r.s = this.s;\n }\n\n // (protected) set from integer value x, -DV <= x < DV\n function bnpFromInt(x) {\n this.t = 1;\n this.s = (x<0)?-1:0;\n if(x > 0) this[0] = x;\n else if(x < -1) this[0] = x+this.DV;\n else this.t = 0;\n }\n\n // return bigint initialized to value\n function nbv(i) { var r = nbi(); r.fromInt(i); return r; }\n\n // (protected) set from string and radix\n function bnpFromString(s,b) {\n var k;\n if(b == 16) k = 4;\n else if(b == 8) k = 3;\n else if(b == 256) k = 8; // byte array\n else if(b == 2) k = 1;\n else if(b == 32) k = 5;\n else if(b == 4) k = 2;\n else { this.fromRadix(s,b); return; }\n this.t = 0;\n this.s = 0;\n var i = s.length, mi = false, sh = 0;\n while(--i >= 0) {\n var x = (k==8)?s[i]&0xff:intAt(s,i);\n if(x < 0) {\n if(s.charAt(i) == \"-\") mi = true;\n continue;\n }\n mi = false;\n if(sh == 0)\n this[this.t++] = x;\n else if(sh+k > this.DB) {\n this[this.t-1] |= (x&((1<<(this.DB-sh))-1))<<sh;\n this[this.t++] = (x>>(this.DB-sh));\n }\n else\n this[this.t-1] |= x<<sh;\n sh += k;\n if(sh >= this.DB) sh -= this.DB;\n }\n if(k == 8 && (s[0]&0x80) != 0) {\n this.s = -1;\n if(sh > 0) this[this.t-1] |= ((1<<(this.DB-sh))-1)<<sh;\n }\n this.clamp();\n if(mi) BigInteger.ZERO.subTo(this,this);\n }\n\n // (protected) clamp off excess high words\n function bnpClamp() {\n var c = this.s&this.DM;\n while(this.t > 0 && this[this.t-1] == c) --this.t;\n }\n\n // (public) return string representation in given radix\n function bnToString(b) {\n if(this.s < 0) return \"-\"+this.negate().toString(b);\n var k;\n if(b == 16) k = 4;\n else if(b == 8) k = 3;\n else if(b == 2) k = 1;\n else if(b == 32) k = 5;\n else if(b == 4) k = 2;\n else return this.toRadix(b);\n var km = (1<<k)-1, d, m = false, r = \"\", i = this.t;\n var p = this.DB-(i*this.DB)%k;\n if(i-- > 0) {\n if(p < this.DB && (d = this[i]>>p) > 0) { m = true; r = int2char(d); }\n while(i >= 0) {\n if(p < k) {\n d = (this[i]&((1<<p)-1))<<(k-p);\n d |= this[--i]>>(p+=this.DB-k);\n }\n else {\n d = (this[i]>>(p-=k))&km;\n if(p <= 0) { p += this.DB; --i; }\n }\n if(d > 0) m = true;\n if(m) r += int2char(d);\n }\n }\n return m?r:\"0\";\n }\n\n // (public) -this\n function bnNegate() { var r = nbi(); BigInteger.ZERO.subTo(this,r); return r; }\n\n // (public) |this|\n function bnAbs() { return (this.s<0)?this.negate():this; }\n\n // (public) return + if this > a, - if this < a, 0 if equal\n function bnCompareTo(a) {\n var r = this.s-a.s;\n if(r != 0) return r;\n var i = this.t;\n r = i-a.t;\n if(r != 0) return (this.s<0)?-r:r;\n while(--i >= 0) if((r=this[i]-a[i]) != 0) return r;\n return 0;\n }\n\n // returns bit length of the integer x\n function nbits(x) {\n var r = 1, t;\n if((t=x>>>16) != 0) { x = t; r += 16; }\n if((t=x>>8) != 0) { x = t; r += 8; }\n if((t=x>>4) != 0) { x = t; r += 4; }\n if((t=x>>2) != 0) { x = t; r += 2; }\n if((t=x>>1) != 0) { x = t; r += 1; }\n return r;\n }\n\n // (public) return the number of bits in \"this\"\n function bnBitLength() {\n if(this.t <= 0) return 0;\n return this.DB*(this.t-1)+nbits(this[this.t-1]^(this.s&this.DM));\n }\n\n // (protected) r = this << n*DB\n function bnpDLShiftTo(n,r) {\n var i;\n for(i = this.t-1; i >= 0; --i) r[i+n] = this[i];\n for(i = n-1; i >= 0; --i) r[i] = 0;\n r.t = this.t+n;\n r.s = this.s;\n }\n\n // (protected) r = this >> n*DB\n function bnpDRShiftTo(n,r) {\n for(var i = n; i < this.t; ++i) r[i-n] = this[i];\n r.t = Math.max(this.t-n,0);\n r.s = this.s;\n }\n\n // (protected) r = this << n\n function bnpLShiftTo(n,r) {\n var bs = n%this.DB;\n var cbs = this.DB-bs;\n var bm = (1<<cbs)-1;\n var ds = Math.floor(n/this.DB), c = (this.s<<bs)&this.DM, i;\n for(i = this.t-1; i >= 0; --i) {\n r[i+ds+1] = (this[i]>>cbs)|c;\n c = (this[i]&bm)<<bs;\n }\n for(i = ds-1; i >= 0; --i) r[i] = 0;\n r[ds] = c;\n r.t = this.t+ds+1;\n r.s = this.s;\n r.clamp();\n }\n\n // (protected) r = this >> n\n function bnpRShiftTo(n,r) {\n r.s = this.s;\n var ds = Math.floor(n/this.DB);\n if(ds >= this.t) { r.t = 0; return; }\n var bs = n%this.DB;\n var cbs = this.DB-bs;\n var bm = (1<<bs)-1;\n r[0] = this[ds]>>bs;\n for(var i = ds+1; i < this.t; ++i) {\n r[i-ds-1] |= (this[i]&bm)<<cbs;\n r[i-ds] = this[i]>>bs;\n }\n if(bs > 0) r[this.t-ds-1] |= (this.s&bm)<<cbs;\n r.t = this.t-ds;\n r.clamp();\n }\n\n // (protected) r = this - a\n function bnpSubTo(a,r) {\n var i = 0, c = 0, m = Math.min(a.t,this.t);\n while(i < m) {\n c += this[i]-a[i];\n r[i++] = c&this.DM;\n c >>= this.DB;\n }\n if(a.t < this.t) {\n c -= a.s;\n while(i < this.t) {\n c += this[i];\n r[i++] = c&this.DM;\n c >>= this.DB;\n }\n c += this.s;\n }\n else {\n c += this.s;\n while(i < a.t) {\n c -= a[i];\n r[i++] = c&this.DM;\n c >>= this.DB;\n }\n c -= a.s;\n }\n r.s = (c<0)?-1:0;\n if(c < -1) r[i++] = this.DV+c;\n else if(c > 0) r[i++] = c;\n r.t = i;\n r.clamp();\n }\n\n // (protected) r = this * a, r != this,a (HAC 14.12)\n // \"this\" should be the larger one if appropriate.\n function bnpMultiplyTo(a,r) {\n var x = this.abs(), y = a.abs();\n var i = x.t;\n r.t = i+y.t;\n while(--i >= 0) r[i] = 0;\n for(i = 0; i < y.t; ++i) r[i+x.t] = x.am(0,y[i],r,i,0,x.t);\n r.s = 0;\n r.clamp();\n if(this.s != a.s) BigInteger.ZERO.subTo(r,r);\n }\n\n // (protected) r = this^2, r != this (HAC 14.16)\n function bnpSquareTo(r) {\n var x = this.abs();\n var i = r.t = 2*x.t;\n while(--i >= 0) r[i] = 0;\n for(i = 0; i < x.t-1; ++i) {\n var c = x.am(i,x[i],r,2*i,0,1);\n if((r[i+x.t]+=x.am(i+1,2*x[i],r,2*i+1,c,x.t-i-1)) >= x.DV) {\n r[i+x.t] -= x.DV;\n r[i+x.t+1] = 1;\n }\n }\n if(r.t > 0) r[r.t-1] += x.am(i,x[i],r,2*i,0,1);\n r.s = 0;\n r.clamp();\n }\n\n // (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)\n // r != q, this != m. q or r may be null.\n function bnpDivRemTo(m,q,r) {\n var pm = m.abs();\n if(pm.t <= 0) return;\n var pt = this.abs();\n if(pt.t < pm.t) {\n if(q != null) q.fromInt(0);\n if(r != null) this.copyTo(r);\n return;\n }\n if(r == null) r = nbi();\n var y = nbi(), ts = this.s, ms = m.s;\n var nsh = this.DB-nbits(pm[pm.t-1]); // normalize modulus\n if(nsh > 0) { pm.lShiftTo(nsh,y); pt.lShiftTo(nsh,r); }\n else { pm.copyTo(y); pt.copyTo(r); }\n var ys = y.t;\n var y0 = y[ys-1];\n if(y0 == 0) return;\n var yt = y0*(1<<this.F1)+((ys>1)?y[ys-2]>>this.F2:0);\n var d1 = this.FV/yt, d2 = (1<<this.F1)/yt, e = 1<<this.F2;\n var i = r.t, j = i-ys, t = (q==null)?nbi():q;\n y.dlShiftTo(j,t);\n if(r.compareTo(t) >= 0) {\n r[r.t++] = 1;\n r.subTo(t,r);\n }\n BigInteger.ONE.dlShiftTo(ys,t);\n t.subTo(y,y); // \"negative\" y so we can replace sub with am later\n while(y.t < ys) y[y.t++] = 0;\n while(--j >= 0) {\n // Estimate quotient digit\n var qd = (r[--i]==y0)?this.DM:Math.floor(r[i]*d1+(r[i-1]+e)*d2);\n if((r[i]+=y.am(0,qd,r,j,0,ys)) < qd) { // Try it out\n y.dlShiftTo(j,t);\n r.subTo(t,r);\n while(r[i] < --qd) r.subTo(t,r);\n }\n }\n if(q != null) {\n r.drShiftTo(ys,q);\n if(ts != ms) BigInteger.ZERO.subTo(q,q);\n }\n r.t = ys;\n r.clamp();\n if(nsh > 0) r.rShiftTo(nsh,r); // Denormalize remainder\n if(ts < 0) BigInteger.ZERO.subTo(r,r);\n }\n\n // (public) this mod a\n function bnMod(a) {\n var r = nbi();\n this.abs().divRemTo(a,null,r);\n if(this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r,r);\n return r;\n }\n\n // Modular reduction using \"classic\" algorithm\n function Classic(m) { this.m = m; }\n function cConvert(x) {\n if(x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m);\n else return x;\n }\n function cRevert(x) { return x; }\n function cReduce(x) { x.divRemTo(this.m,null,x); }\n function cMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }\n function cSqrTo(x,r) { x.squareTo(r); this.reduce(r); }\n\n Classic.prototype.convert = cConvert;\n Classic.prototype.revert = cRevert;\n Classic.prototype.reduce = cReduce;\n Classic.prototype.mulTo = cMulTo;\n Classic.prototype.sqrTo = cSqrTo;\n\n // (protected) return \"-1/this % 2^DB\"; useful for Mont. reduction\n // justification:\n // xy == 1 (mod m)\n // xy = 1+km\n // xy(2-xy) = (1+km)(1-km)\n // x[y(2-xy)] = 1-k^2m^2\n // x[y(2-xy)] == 1 (mod m^2)\n // if y is 1/x mod m, then y(2-xy) is 1/x mod m^2\n // should reduce x and y(2-xy) by m^2 at each step to keep size bounded.\n // JS multiply \"overflows\" differently from C/C++, so care is needed here.\n function bnpInvDigit() {\n if(this.t < 1) return 0;\n var x = this[0];\n if((x&1) == 0) return 0;\n var y = x&3; // y == 1/x mod 2^2\n y = (y*(2-(x&0xf)*y))&0xf; // y == 1/x mod 2^4\n y = (y*(2-(x&0xff)*y))&0xff; // y == 1/x mod 2^8\n y = (y*(2-(((x&0xffff)*y)&0xffff)))&0xffff; // y == 1/x mod 2^16\n // last step - calculate inverse mod DV directly;\n // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints\n y = (y*(2-x*y%this.DV))%this.DV; // y == 1/x mod 2^dbits\n // we really want the negative inverse, and -DV < y < DV\n return (y>0)?this.DV-y:-y;\n }\n\n // Montgomery reduction\n function Montgomery(m) {\n this.m = m;\n this.mp = m.invDigit();\n this.mpl = this.mp&0x7fff;\n this.mph = this.mp>>15;\n this.um = (1<<(m.DB-15))-1;\n this.mt2 = 2*m.t;\n }\n\n // xR mod m\n function montConvert(x) {\n var r = nbi();\n x.abs().dlShiftTo(this.m.t,r);\n r.divRemTo(this.m,null,r);\n if(x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r,r);\n return r;\n }\n\n // x/R mod m\n function montRevert(x) {\n var r = nbi();\n x.copyTo(r);\n this.reduce(r);\n return r;\n }\n\n // x = x/R mod m (HAC 14.32)\n function montReduce(x) {\n while(x.t <= this.mt2) // pad x so am has enough room later\n x[x.t++] = 0;\n for(var i = 0; i < this.m.t; ++i) {\n // faster way of calculating u0 = x[i]*mp mod DV\n var j = x[i]&0x7fff;\n var u0 = (j*this.mpl+(((j*this.mph+(x[i]>>15)*this.mpl)&this.um)<<15))&x.DM;\n // use am to combine the multiply-shift-add into one call\n j = i+this.m.t;\n x[j] += this.m.am(0,u0,x,i,0,this.m.t);\n // propagate carry\n while(x[j] >= x.DV) { x[j] -= x.DV; x[++j]++; }\n }\n x.clamp();\n x.drShiftTo(this.m.t,x);\n if(x.compareTo(this.m) >= 0) x.subTo(this.m,x);\n }\n\n // r = \"x^2/R mod m\"; x != r\n function montSqrTo(x,r) { x.squareTo(r); this.reduce(r); }\n\n // r = \"xy/R mod m\"; x,y != r\n function montMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }\n\n Montgomery.prototype.convert = montConvert;\n Montgomery.prototype.revert = montRevert;\n Montgomery.prototype.reduce = montReduce;\n Montgomery.prototype.mulTo = montMulTo;\n Montgomery.prototype.sqrTo = montSqrTo;\n\n // (protected) true iff this is even\n function bnpIsEven() { return ((this.t>0)?(this[0]&1):this.s) == 0; }\n\n // (protected) this^e, e < 2^32, doing sqr and mul with \"r\" (HAC 14.79)\n function bnpExp(e,z) {\n if(e > 0xffffffff || e < 1) return BigInteger.ONE;\n var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e)-1;\n g.copyTo(r);\n while(--i >= 0) {\n z.sqrTo(r,r2);\n if((e&(1<<i)) > 0) z.mulTo(r2,g,r);\n else { var t = r; r = r2; r2 = t; }\n }\n return z.revert(r);\n }\n\n // (public) this^e % m, 0 <= e < 2^32\n function bnModPowInt(e,m) {\n var z;\n if(e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m);\n return this.exp(e,z);\n }\n\n // protected\n BigInteger.prototype.copyTo = bnpCopyTo;\n BigInteger.prototype.fromInt = bnpFromInt;\n BigInteger.prototype.fromString = bnpFromString;\n BigInteger.prototype.clamp = bnpClamp;\n BigInteger.prototype.dlShiftTo = bnpDLShiftTo;\n BigInteger.prototype.drShiftTo = bnpDRShiftTo;\n BigInteger.prototype.lShiftTo = bnpLShiftTo;\n BigInteger.prototype.rShiftTo = bnpRShiftTo;\n BigInteger.prototype.subTo = bnpSubTo;\n BigInteger.prototype.multiplyTo = bnpMultiplyTo;\n BigInteger.prototype.squareTo = bnpSquareTo;\n BigInteger.prototype.divRemTo = bnpDivRemTo;\n BigInteger.prototype.invDigit = bnpInvDigit;\n BigInteger.prototype.isEven = bnpIsEven;\n BigInteger.prototype.exp = bnpExp;\n\n // public\n BigInteger.prototype.toString = bnToString;\n BigInteger.prototype.negate = bnNegate;\n BigInteger.prototype.abs = bnAbs;\n BigInteger.prototype.compareTo = bnCompareTo;\n BigInteger.prototype.bitLength = bnBitLength;\n BigInteger.prototype.mod = bnMod;\n BigInteger.prototype.modPowInt = bnModPowInt;\n\n // \"constants\"\n BigInteger.ZERO = nbv(0);\n BigInteger.ONE = nbv(1);\n\n // Copyright (c) 2005-2009 Tom Wu\n // All Rights Reserved.\n // See \"LICENSE\" for details.\n\n // Extended JavaScript BN functions, required for RSA private ops.\n\n // Version 1.1: new BigInteger(\"0\", 10) returns \"proper\" zero\n // Version 1.2: square() API, isProbablePrime fix\n\n // (public)\n function bnClone() { var r = nbi(); this.copyTo(r); return r; }\n\n // (public) return value as integer\n function bnIntValue() {\n if(this.s < 0) {\n if(this.t == 1) return this[0]-this.DV;\n else if(this.t == 0) return -1;\n }\n else if(this.t == 1) return this[0];\n else if(this.t == 0) return 0;\n // assumes 16 < DB < 32\n return ((this[1]&((1<<(32-this.DB))-1))<<this.DB)|this[0];\n }\n\n // (public) return value as byte\n function bnByteValue() { return (this.t==0)?this.s:(this[0]<<24)>>24; }\n\n // (public) return value as short (assumes DB>=16)\n function bnShortValue() { return (this.t==0)?this.s:(this[0]<<16)>>16; }\n\n // (protected) return x s.t. r^x < DV\n function bnpChunkSize(r) { return Math.floor(Math.LN2*this.DB/Math.log(r)); }\n\n // (public) 0 if this == 0, 1 if this > 0\n function bnSigNum() {\n if(this.s < 0) return -1;\n else if(this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0;\n else return 1;\n }\n\n // (protected) convert to radix string\n function bnpToRadix(b) {\n if(b == null) b = 10;\n if(this.signum() == 0 || b < 2 || b > 36) return \"0\";\n var cs = this.chunkSize(b);\n var a = Math.pow(b,cs);\n var d = nbv(a), y = nbi(), z = nbi(), r = \"\";\n this.divRemTo(d,y,z);\n while(y.signum() > 0) {\n r = (a+z.intValue()).toString(b).substr(1) + r;\n y.divRemTo(d,y,z);\n }\n return z.intValue().toString(b) + r;\n }\n\n // (protected) convert from radix string\n function bnpFromRadix(s,b) {\n this.fromInt(0);\n if(b == null) b = 10;\n var cs = this.chunkSize(b);\n var d = Math.pow(b,cs), mi = false, j = 0, w = 0;\n for(var i = 0; i < s.length; ++i) {\n var x = intAt(s,i);\n if(x < 0) {\n if(s.charAt(i) == \"-\" && this.signum() == 0) mi = true;\n continue;\n }\n w = b*w+x;\n if(++j >= cs) {\n this.dMultiply(d);\n this.dAddOffset(w,0);\n j = 0;\n w = 0;\n }\n }\n if(j > 0) {\n this.dMultiply(Math.pow(b,j));\n this.dAddOffset(w,0);\n }\n if(mi) BigInteger.ZERO.subTo(this,this);\n }\n\n // (protected) alternate constructor\n function bnpFromNumber(a,b,c) {\n if(\"number\" == typeof b) {\n // new BigInteger(int,int,RNG)\n if(a < 2) this.fromInt(1);\n else {\n this.fromNumber(a,c);\n if(!this.testBit(a-1)) // force MSB set\n this.bitwiseTo(BigInteger.ONE.shiftLeft(a-1),op_or,this);\n if(this.isEven()) this.dAddOffset(1,0); // force odd\n while(!this.isProbablePrime(b)) {\n this.dAddOffset(2,0);\n if(this.bitLength() > a) this.subTo(BigInteger.ONE.shiftLeft(a-1),this);\n }\n }\n }\n else {\n // new BigInteger(int,RNG)\n var x = new Array(), t = a&7;\n x.length = (a>>3)+1;\n b.nextBytes(x);\n if(t > 0) x[0] &= ((1<<t)-1); else x[0] = 0;\n this.fromString(x,256);\n }\n }\n\n // (public) convert to bigendian byte array\n function bnToByteArray() {\n var i = this.t, r = new Array();\n r[0] = this.s;\n var p = this.DB-(i*this.DB)%8, d, k = 0;\n if(i-- > 0) {\n if(p < this.DB && (d = this[i]>>p) != (this.s&this.DM)>>p)\n r[k++] = d|(this.s<<(this.DB-p));\n while(i >= 0) {\n if(p < 8) {\n d = (this[i]&((1<<p)-1))<<(8-p);\n d |= this[--i]>>(p+=this.DB-8);\n }\n else {\n d = (this[i]>>(p-=8))&0xff;\n if(p <= 0) { p += this.DB; --i; }\n }\n if((d&0x80) != 0) d |= -256;\n if(k == 0 && (this.s&0x80) != (d&0x80)) ++k;\n if(k > 0 || d != this.s) r[k++] = d;\n }\n }\n return r;\n }\n\n function bnEquals(a) { return(this.compareTo(a)==0); }\n function bnMin(a) { return(this.compareTo(a)<0)?this:a; }\n function bnMax(a) { return(this.compareTo(a)>0)?this:a; }\n\n // (protected) r = this op a (bitwise)\n function bnpBitwiseTo(a,op,r) {\n var i, f, m = Math.min(a.t,this.t);\n for(i = 0; i < m; ++i) r[i] = op(this[i],a[i]);\n if(a.t < this.t) {\n f = a.s&this.DM;\n for(i = m; i < this.t; ++i) r[i] = op(this[i],f);\n r.t = this.t;\n }\n else {\n f = this.s&this.DM;\n for(i = m; i < a.t; ++i) r[i] = op(f,a[i]);\n r.t = a.t;\n }\n r.s = op(this.s,a.s);\n r.clamp();\n }\n\n // (public) this & a\n function op_and(x,y) { return x&y; }\n function bnAnd(a) { var r = nbi(); this.bitwiseTo(a,op_and,r); return r; }\n\n // (public) this | a\n function op_or(x,y) { return x|y; }\n function bnOr(a) { var r = nbi(); this.bitwiseTo(a,op_or,r); return r; }\n\n // (public) this ^ a\n function op_xor(x,y) { return x^y; }\n function bnXor(a) { var r = nbi(); this.bitwiseTo(a,op_xor,r); return r; }\n\n // (public) this & ~a\n function op_andnot(x,y) { return x&~y; }\n function bnAndNot(a) { var r = nbi(); this.bitwiseTo(a,op_andnot,r); return r; }\n\n // (public) ~this\n function bnNot() {\n var r = nbi();\n for(var i = 0; i < this.t; ++i) r[i] = this.DM&~this[i];\n r.t = this.t;\n r.s = ~this.s;\n return r;\n }\n\n // (public) this << n\n function bnShiftLeft(n) {\n var r = nbi();\n if(n < 0) this.rShiftTo(-n,r); else this.lShiftTo(n,r);\n return r;\n }\n\n // (public) this >> n\n function bnShiftRight(n) {\n var r = nbi();\n if(n < 0) this.lShiftTo(-n,r); else this.rShiftTo(n,r);\n return r;\n }\n\n // return index of lowest 1-bit in x, x < 2^31\n function lbit(x) {\n if(x == 0) return -1;\n var r = 0;\n if((x&0xffff) == 0) { x >>= 16; r += 16; }\n if((x&0xff) == 0) { x >>= 8; r += 8; }\n if((x&0xf) == 0) { x >>= 4; r += 4; }\n if((x&3) == 0) { x >>= 2; r += 2; }\n if((x&1) == 0) ++r;\n return r;\n }\n\n // (public) returns index of lowest 1-bit (or -1 if none)\n function bnGetLowestSetBit() {\n for(var i = 0; i < this.t; ++i)\n if(this[i] != 0) return i*this.DB+lbit(this[i]);\n if(this.s < 0) return this.t*this.DB;\n return -1;\n }\n\n // return number of 1 bits in x\n function cbit(x) {\n var r = 0;\n while(x != 0) { x &= x-1; ++r; }\n return r;\n }\n\n // (public) return number of set bits\n function bnBitCount() {\n var r = 0, x = this.s&this.DM;\n for(var i = 0; i < this.t; ++i) r += cbit(this[i]^x);\n return r;\n }\n\n // (public) true iff nth bit is set\n function bnTestBit(n) {\n var j = Math.floor(n/this.DB);\n if(j >= this.t) return(this.s!=0);\n return((this[j]&(1<<(n%this.DB)))!=0);\n }\n\n // (protected) this op (1<<n)\n function bnpChangeBit(n,op) {\n var r = BigInteger.ONE.shiftLeft(n);\n this.bitwiseTo(r,op,r);\n return r;\n }\n\n // (public) this | (1<<n)\n function bnSetBit(n) { return this.changeBit(n,op_or); }\n\n // (public) this & ~(1<<n)\n function bnClearBit(n) { return this.changeBit(n,op_andnot); }\n\n // (public) this ^ (1<<n)\n function bnFlipBit(n) { return this.changeBit(n,op_xor); }\n\n // (protected) r = this + a\n function bnpAddTo(a,r) {\n var i = 0, c = 0, m = Math.min(a.t,this.t);\n while(i < m) {\n c += this[i]+a[i];\n r[i++] = c&this.DM;\n c >>= this.DB;\n }\n if(a.t < this.t) {\n c += a.s;\n while(i < this.t) {\n c += this[i];\n r[i++] = c&this.DM;\n c >>= this.DB;\n }\n c += this.s;\n }\n else {\n c += this.s;\n while(i < a.t) {\n c += a[i];\n r[i++] = c&this.DM;\n c >>= this.DB;\n }\n c += a.s;\n }\n r.s = (c<0)?-1:0;\n if(c > 0) r[i++] = c;\n else if(c < -1) r[i++] = this.DV+c;\n r.t = i;\n r.clamp();\n }\n\n // (public) this + a\n function bnAdd(a) { var r = nbi(); this.addTo(a,r); return r; }\n\n // (public) this - a\n function bnSubtract(a) { var r = nbi(); this.subTo(a,r); return r; }\n\n // (public) this * a\n function bnMultiply(a) { var r = nbi(); this.multiplyTo(a,r); return r; }\n\n // (public) this^2\n function bnSquare() { var r = nbi(); this.squareTo(r); return r; }\n\n // (public) this / a\n function bnDivide(a) { var r = nbi(); this.divRemTo(a,r,null); return r; }\n\n // (public) this % a\n function bnRemainder(a) { var r = nbi(); this.divRemTo(a,null,r); return r; }\n\n // (public) [this/a,this%a]\n function bnDivideAndRemainder(a) {\n var q = nbi(), r = nbi();\n this.divRemTo(a,q,r);\n return new Array(q,r);\n }\n\n // (protected) this *= n, this >= 0, 1 < n < DV\n function bnpDMultiply(n) {\n this[this.t] = this.am(0,n-1,this,0,0,this.t);\n ++this.t;\n this.clamp();\n }\n\n // (protected) this += n << w words, this >= 0\n function bnpDAddOffset(n,w) {\n if(n == 0) return;\n while(this.t <= w) this[this.t++] = 0;\n this[w] += n;\n while(this[w] >= this.DV) {\n this[w] -= this.DV;\n if(++w >= this.t) this[this.t++] = 0;\n ++this[w];\n }\n }\n\n // A \"null\" reducer\n function NullExp() {}\n function nNop(x) { return x; }\n function nMulTo(x,y,r) { x.multiplyTo(y,r); }\n function nSqrTo(x,r) { x.squareTo(r); }\n\n NullExp.prototype.convert = nNop;\n NullExp.prototype.revert = nNop;\n NullExp.prototype.mulTo = nMulTo;\n NullExp.prototype.sqrTo = nSqrTo;\n\n // (public) this^e\n function bnPow(e) { return this.exp(e,new NullExp()); }\n\n // (protected) r = lower n words of \"this * a\", a.t <= n\n // \"this\" should be the larger one if appropriate.\n function bnpMultiplyLowerTo(a,n,r) {\n var i = Math.min(this.t+a.t,n);\n r.s = 0; // assumes a,this >= 0\n r.t = i;\n while(i > 0) r[--i] = 0;\n var j;\n for(j = r.t-this.t; i < j; ++i) r[i+this.t] = this.am(0,a[i],r,i,0,this.t);\n for(j = Math.min(a.t,n); i < j; ++i) this.am(0,a[i],r,i,0,n-i);\n r.clamp();\n }\n\n // (protected) r = \"this * a\" without lower n words, n > 0\n // \"this\" should be the larger one if appropriate.\n function bnpMultiplyUpperTo(a,n,r) {\n --n;\n var i = r.t = this.t+a.t-n;\n r.s = 0; // assumes a,this >= 0\n while(--i >= 0) r[i] = 0;\n for(i = Math.max(n-this.t,0); i < a.t; ++i)\n r[this.t+i-n] = this.am(n-i,a[i],r,0,0,this.t+i-n);\n r.clamp();\n r.drShiftTo(1,r);\n }\n\n // Barrett modular reduction\n function Barrett(m) {\n // setup Barrett\n this.r2 = nbi();\n this.q3 = nbi();\n BigInteger.ONE.dlShiftTo(2*m.t,this.r2);\n this.mu = this.r2.divide(m);\n this.m = m;\n }\n\n function barrettConvert(x) {\n if(x.s < 0 || x.t > 2*this.m.t) return x.mod(this.m);\n else if(x.compareTo(this.m) < 0) return x;\n else { var r = nbi(); x.copyTo(r); this.reduce(r); return r; }\n }\n\n function barrettRevert(x) { return x; }\n\n // x = x mod m (HAC 14.42)\n function barrettReduce(x) {\n x.drShiftTo(this.m.t-1,this.r2);\n if(x.t > this.m.t+1) { x.t = this.m.t+1; x.clamp(); }\n this.mu.multiplyUpperTo(this.r2,this.m.t+1,this.q3);\n this.m.multiplyLowerTo(this.q3,this.m.t+1,this.r2);\n while(x.compareTo(this.r2) < 0) x.dAddOffset(1,this.m.t+1);\n x.subTo(this.r2,x);\n while(x.compareTo(this.m) >= 0) x.subTo(this.m,x);\n }\n\n // r = x^2 mod m; x != r\n function barrettSqrTo(x,r) { x.squareTo(r); this.reduce(r); }\n\n // r = x*y mod m; x,y != r\n function barrettMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }\n\n Barrett.prototype.convert = barrettConvert;\n Barrett.prototype.revert = barrettRevert;\n Barrett.prototype.reduce = barrettReduce;\n Barrett.prototype.mulTo = barrettMulTo;\n Barrett.prototype.sqrTo = barrettSqrTo;\n\n // (public) this^e % m (HAC 14.85)\n function bnModPow(e,m) {\n var i = e.bitLength(), k, r = nbv(1), z;\n if(i <= 0) return r;\n else if(i < 18) k = 1;\n else if(i < 48) k = 3;\n else if(i < 144) k = 4;\n else if(i < 768) k = 5;\n else k = 6;\n if(i < 8)\n z = new Classic(m);\n else if(m.isEven())\n z = new Barrett(m);\n else\n z = new Montgomery(m);\n\n // precomputation\n var g = new Array(), n = 3, k1 = k-1, km = (1<<k)-1;\n g[1] = z.convert(this);\n if(k > 1) {\n var g2 = nbi();\n z.sqrTo(g[1],g2);\n while(n <= km) {\n g[n] = nbi();\n z.mulTo(g2,g[n-2],g[n]);\n n += 2;\n }\n }\n\n var j = e.t-1, w, is1 = true, r2 = nbi(), t;\n i = nbits(e[j])-1;\n while(j >= 0) {\n if(i >= k1) w = (e[j]>>(i-k1))&km;\n else {\n w = (e[j]&((1<<(i+1))-1))<<(k1-i);\n if(j > 0) w |= e[j-1]>>(this.DB+i-k1);\n }\n\n n = k;\n while((w&1) == 0) { w >>= 1; --n; }\n if((i -= n) < 0) { i += this.DB; --j; }\n if(is1) { // ret == 1, don't bother squaring or multiplying it\n g[w].copyTo(r);\n is1 = false;\n }\n else {\n while(n > 1) { z.sqrTo(r,r2); z.sqrTo(r2,r); n -= 2; }\n if(n > 0) z.sqrTo(r,r2); else { t = r; r = r2; r2 = t; }\n z.mulTo(r2,g[w],r);\n }\n\n while(j >= 0 && (e[j]&(1<<i)) == 0) {\n z.sqrTo(r,r2); t = r; r = r2; r2 = t;\n if(--i < 0) { i = this.DB-1; --j; }\n }\n }\n return z.revert(r);\n }\n\n // (public) gcd(this,a) (HAC 14.54)\n function bnGCD(a) {\n var x = (this.s<0)?this.negate():this.clone();\n var y = (a.s<0)?a.negate():a.clone();\n if(x.compareTo(y) < 0) { var t = x; x = y; y = t; }\n var i = x.getLowestSetBit(), g = y.getLowestSetBit();\n if(g < 0) return x;\n if(i < g) g = i;\n if(g > 0) {\n x.rShiftTo(g,x);\n y.rShiftTo(g,y);\n }\n while(x.signum() > 0) {\n if((i = x.getLowestSetBit()) > 0) x.rShiftTo(i,x);\n if((i = y.getLowestSetBit()) > 0) y.rShiftTo(i,y);\n if(x.compareTo(y) >= 0) {\n x.subTo(y,x);\n x.rShiftTo(1,x);\n }\n else {\n y.subTo(x,y);\n y.rShiftTo(1,y);\n }\n }\n if(g > 0) y.lShiftTo(g,y);\n return y;\n }\n\n // (protected) this % n, n < 2^26\n function bnpModInt(n) {\n if(n <= 0) return 0;\n var d = this.DV%n, r = (this.s<0)?n-1:0;\n if(this.t > 0)\n if(d == 0) r = this[0]%n;\n else for(var i = this.t-1; i >= 0; --i) r = (d*r+this[i])%n;\n return r;\n }\n\n // (public) 1/this % m (HAC 14.61)\n function bnModInverse(m) {\n var ac = m.isEven();\n if((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO;\n var u = m.clone(), v = this.clone();\n var a = nbv(1), b = nbv(0), c = nbv(0), d = nbv(1);\n while(u.signum() != 0) {\n while(u.isEven()) {\n u.rShiftTo(1,u);\n if(ac) {\n if(!a.isEven() || !b.isEven()) { a.addTo(this,a); b.subTo(m,b); }\n a.rShiftTo(1,a);\n }\n else if(!b.isEven()) b.subTo(m,b);\n b.rShiftTo(1,b);\n }\n while(v.isEven()) {\n v.rShiftTo(1,v);\n if(ac) {\n if(!c.isEven() || !d.isEven()) { c.addTo(this,c); d.subTo(m,d); }\n c.rShiftTo(1,c);\n }\n else if(!d.isEven()) d.subTo(m,d);\n d.rShiftTo(1,d);\n }\n if(u.compareTo(v) >= 0) {\n u.subTo(v,u);\n if(ac) a.subTo(c,a);\n b.subTo(d,b);\n }\n else {\n v.subTo(u,v);\n if(ac) c.subTo(a,c);\n d.subTo(b,d);\n }\n }\n if(v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO;\n if(d.compareTo(m) >= 0) return d.subtract(m);\n if(d.signum() < 0) d.addTo(m,d); else return d;\n if(d.signum() < 0) return d.add(m); else return d;\n }\n\n var lowprimes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997];\n var lplim = (1<<26)/lowprimes[lowprimes.length-1];\n\n // (public) test primality with certainty >= 1-.5^t\n function bnIsProbablePrime(t) {\n var i, x = this.abs();\n if(x.t == 1 && x[0] <= lowprimes[lowprimes.length-1]) {\n for(i = 0; i < lowprimes.length; ++i)\n if(x[0] == lowprimes[i]) return true;\n return false;\n }\n if(x.isEven()) return false;\n i = 1;\n while(i < lowprimes.length) {\n var m = lowprimes[i], j = i+1;\n while(j < lowprimes.length && m < lplim) m *= lowprimes[j++];\n m = x.modInt(m);\n while(i < j) if(m%lowprimes[i++] == 0) return false;\n }\n return x.millerRabin(t);\n }\n\n // (protected) true if probably prime (HAC 4.24, Miller-Rabin)\n function bnpMillerRabin(t) {\n var n1 = this.subtract(BigInteger.ONE);\n var k = n1.getLowestSetBit();\n if(k <= 0) return false;\n var r = n1.shiftRight(k);\n t = (t+1)>>1;\n if(t > lowprimes.length) t = lowprimes.length;\n var a = nbi();\n for(var i = 0; i < t; ++i) {\n //Pick bases at random, instead of starting at 2\n a.fromInt(lowprimes[Math.floor(Math.random()*lowprimes.length)]);\n var y = a.modPow(r,this);\n if(y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {\n var j = 1;\n while(j++ < k && y.compareTo(n1) != 0) {\n y = y.modPowInt(2,this);\n if(y.compareTo(BigInteger.ONE) == 0) return false;\n }\n if(y.compareTo(n1) != 0) return false;\n }\n }\n return true;\n }\n\n // protected\n BigInteger.prototype.chunkSize = bnpChunkSize;\n BigInteger.prototype.toRadix = bnpToRadix;\n BigInteger.prototype.fromRadix = bnpFromRadix;\n BigInteger.prototype.fromNumber = bnpFromNumber;\n BigInteger.prototype.bitwiseTo = bnpBitwiseTo;\n BigInteger.prototype.changeBit = bnpChangeBit;\n BigInteger.prototype.addTo = bnpAddTo;\n BigInteger.prototype.dMultiply = bnpDMultiply;\n BigInteger.prototype.dAddOffset = bnpDAddOffset;\n BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;\n BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;\n BigInteger.prototype.modInt = bnpModInt;\n BigInteger.prototype.millerRabin = bnpMillerRabin;\n\n // public\n BigInteger.prototype.clone = bnClone;\n BigInteger.prototype.intValue = bnIntValue;\n BigInteger.prototype.byteValue = bnByteValue;\n BigInteger.prototype.shortValue = bnShortValue;\n BigInteger.prototype.signum = bnSigNum;\n BigInteger.prototype.toByteArray = bnToByteArray;\n BigInteger.prototype.equals = bnEquals;\n BigInteger.prototype.min = bnMin;\n BigInteger.prototype.max = bnMax;\n BigInteger.prototype.and = bnAnd;\n BigInteger.prototype.or = bnOr;\n BigInteger.prototype.xor = bnXor;\n BigInteger.prototype.andNot = bnAndNot;\n BigInteger.prototype.not = bnNot;\n BigInteger.prototype.shiftLeft = bnShiftLeft;\n BigInteger.prototype.shiftRight = bnShiftRight;\n BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;\n BigInteger.prototype.bitCount = bnBitCount;\n BigInteger.prototype.testBit = bnTestBit;\n BigInteger.prototype.setBit = bnSetBit;\n BigInteger.prototype.clearBit = bnClearBit;\n BigInteger.prototype.flipBit = bnFlipBit;\n BigInteger.prototype.add = bnAdd;\n BigInteger.prototype.subtract = bnSubtract;\n BigInteger.prototype.multiply = bnMultiply;\n BigInteger.prototype.divide = bnDivide;\n BigInteger.prototype.remainder = bnRemainder;\n BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;\n BigInteger.prototype.modPow = bnModPow;\n BigInteger.prototype.modInverse = bnModInverse;\n BigInteger.prototype.pow = bnPow;\n BigInteger.prototype.gcd = bnGCD;\n BigInteger.prototype.isProbablePrime = bnIsProbablePrime;\n\n // JSBN-specific extension\n BigInteger.prototype.square = bnSquare;\n\n // Expose the Barrett function\n BigInteger.prototype.Barrett = Barrett\n\n // BigInteger interfaces not implemented in jsbn:\n\n // BigInteger(int signum, byte[] magnitude)\n // double doubleValue()\n // float floatValue()\n // int hashCode()\n // long longValue()\n // static BigInteger valueOf(long val)\n\n // Random number generator - requires a PRNG backend, e.g. prng4.js\n\n // For best results, put code like\n // <body onClick='rng_seed_time();' onKeyPress='rng_seed_time();'>\n // in your main HTML document.\n\n var rng_state;\n var rng_pool;\n var rng_pptr;\n\n // Mix in a 32-bit integer into the pool\n function rng_seed_int(x) {\n rng_pool[rng_pptr++] ^= x & 255;\n rng_pool[rng_pptr++] ^= (x >> 8) & 255;\n rng_pool[rng_pptr++] ^= (x >> 16) & 255;\n rng_pool[rng_pptr++] ^= (x >> 24) & 255;\n if(rng_pptr >= rng_psize) rng_pptr -= rng_psize;\n }\n\n // Mix in the current time (w/milliseconds) into the pool\n function rng_seed_time() {\n rng_seed_int(new Date().getTime());\n }\n\n // Initialize the pool with junk if needed.\n if(rng_pool == null) {\n rng_pool = new Array();\n rng_pptr = 0;\n var t;\n if(typeof window !== \"undefined\" && window.crypto) {\n if (window.crypto.getRandomValues) {\n // Use webcrypto if available\n var ua = new Uint8Array(32);\n window.crypto.getRandomValues(ua);\n for(t = 0; t < 32; ++t)\n rng_pool[rng_pptr++] = ua[t];\n }\n else if(navigator.appName == \"Netscape\" && navigator.appVersion < \"5\") {\n // Extract entropy (256 bits) from NS4 RNG if available\n var z = window.crypto.random(32);\n for(t = 0; t < z.length; ++t)\n rng_pool[rng_pptr++] = z.charCodeAt(t) & 255;\n }\n }\n while(rng_pptr < rng_psize) { // extract some randomness from Math.random()\n t = Math.floor(65536 * Math.random());\n rng_pool[rng_pptr++] = t >>> 8;\n rng_pool[rng_pptr++] = t & 255;\n }\n rng_pptr = 0;\n rng_seed_time();\n //rng_seed_int(window.screenX);\n //rng_seed_int(window.screenY);\n }\n\n function rng_get_byte() {\n if(rng_state == null) {\n rng_seed_time();\n rng_state = prng_newstate();\n rng_state.init(rng_pool);\n for(rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr)\n rng_pool[rng_pptr] = 0;\n rng_pptr = 0;\n //rng_pool = null;\n }\n // TODO: allow reseeding after first request\n return rng_state.next();\n }\n\n function rng_get_bytes(ba) {\n var i;\n for(i = 0; i < ba.length; ++i) ba[i] = rng_get_byte();\n }\n\n function SecureRandom() {}\n\n SecureRandom.prototype.nextBytes = rng_get_bytes;\n\n // prng4.js - uses Arcfour as a PRNG\n\n function Arcfour() {\n this.i = 0;\n this.j = 0;\n this.S = new Array();\n }\n\n // Initialize arcfour context from key, an array of ints, each from [0..255]\n function ARC4init(key) {\n var i, j, t;\n for(i = 0; i < 256; ++i)\n this.S[i] = i;\n j = 0;\n for(i = 0; i < 256; ++i) {\n j = (j + this.S[i] + key[i % key.length]) & 255;\n t = this.S[i];\n this.S[i] = this.S[j];\n this.S[j] = t;\n }\n this.i = 0;\n this.j = 0;\n }\n\n function ARC4next() {\n var t;\n this.i = (this.i + 1) & 255;\n this.j = (this.j + this.S[this.i]) & 255;\n t = this.S[this.i];\n this.S[this.i] = this.S[this.j];\n this.S[this.j] = t;\n return this.S[(t + this.S[this.i]) & 255];\n }\n\n Arcfour.prototype.init = ARC4init;\n Arcfour.prototype.next = ARC4next;\n\n // Plug in your RNG constructor here\n function prng_newstate() {\n return new Arcfour();\n }\n\n // Pool size must be a multiple of 4 and greater than 32.\n // An array of bytes the size of the pool will be passed to init()\n var rng_psize = 256;\n\n if (typeof exports !== 'undefined') {\n exports = module.exports = {\n default: BigInteger,\n BigInteger: BigInteger,\n SecureRandom: SecureRandom,\n };\n } else {\n this.jsbn = {\n BigInteger: BigInteger,\n SecureRandom: SecureRandom\n };\n }\n\n}).call(this);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/jsbn/index.js\n// module id = 12\n// module chunks = 0","'use strict';\n\n\nvar zlib_inflate = require('./zlib/inflate');\nvar utils = require('./utils/common');\nvar strings = require('./utils/strings');\nvar c = require('./zlib/constants');\nvar msg = require('./zlib/messages');\nvar ZStream = require('./zlib/zstream');\nvar GZheader = require('./zlib/gzheader');\n\nvar toString = Object.prototype.toString;\n\n/**\n * class Inflate\n *\n * Generic JS-style wrapper for zlib calls. If you don't need\n * streaming behaviour - use more simple functions: [[inflate]]\n * and [[inflateRaw]].\n **/\n\n/* internal\n * inflate.chunks -> Array\n *\n * Chunks of output data, if [[Inflate#onData]] not overriden.\n **/\n\n/**\n * Inflate.result -> Uint8Array|Array|String\n *\n * Uncompressed result, generated by default [[Inflate#onData]]\n * and [[Inflate#onEnd]] handlers. Filled after you push last chunk\n * (call [[Inflate#push]] with `Z_FINISH` / `true` param) or if you\n * push a chunk with explicit flush (call [[Inflate#push]] with\n * `Z_SYNC_FLUSH` param).\n **/\n\n/**\n * Inflate.err -> Number\n *\n * Error code after inflate finished. 0 (Z_OK) on success.\n * Should be checked if broken data possible.\n **/\n\n/**\n * Inflate.msg -> String\n *\n * Error message, if [[Inflate.err]] != 0\n **/\n\n\n/**\n * new Inflate(options)\n * - options (Object): zlib inflate options.\n *\n * Creates new inflator instance with specified params. Throws exception\n * on bad params. Supported options:\n *\n * - `windowBits`\n * - `dictionary`\n *\n * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n * for more information on these.\n *\n * Additional options, for internal needs:\n *\n * - `chunkSize` - size of generated data chunks (16K by default)\n * - `raw` (Boolean) - do raw inflate\n * - `to` (String) - if equal to 'string', then result will be converted\n * from utf8 to utf16 (javascript) string. When string output requested,\n * chunk length can differ from `chunkSize`, depending on content.\n *\n * By default, when no options set, autodetect deflate/gzip data format via\n * wrapper header.\n *\n * ##### Example:\n *\n * ```javascript\n * var pako = require('pako')\n * , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])\n * , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);\n *\n * var inflate = new pako.Inflate({ level: 3});\n *\n * inflate.push(chunk1, false);\n * inflate.push(chunk2, true); // true -> last chunk\n *\n * if (inflate.err) { throw new Error(inflate.err); }\n *\n * console.log(inflate.result);\n * ```\n **/\nfunction Inflate(options) {\n if (!(this instanceof Inflate)) return new Inflate(options);\n\n this.options = utils.assign({\n chunkSize: 16384,\n windowBits: 0,\n to: ''\n }, options || {});\n\n var opt = this.options;\n\n // Force window size for `raw` data, if not set directly,\n // because we have no header for autodetect.\n if (opt.raw && (opt.windowBits >= 0) && (opt.windowBits < 16)) {\n opt.windowBits = -opt.windowBits;\n if (opt.windowBits === 0) { opt.windowBits = -15; }\n }\n\n // If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate\n if ((opt.windowBits >= 0) && (opt.windowBits < 16) &&\n !(options && options.windowBits)) {\n opt.windowBits += 32;\n }\n\n // Gzip header has no info about windows size, we can do autodetect only\n // for deflate. So, if window size not set, force it to max when gzip possible\n if ((opt.windowBits > 15) && (opt.windowBits < 48)) {\n // bit 3 (16) -> gzipped data\n // bit 4 (32) -> autodetect gzip/deflate\n if ((opt.windowBits & 15) === 0) {\n opt.windowBits |= 15;\n }\n }\n\n this.err = 0; // error code, if happens (0 = Z_OK)\n this.msg = ''; // error message\n this.ended = false; // used to avoid multiple onEnd() calls\n this.chunks = []; // chunks of compressed data\n\n this.strm = new ZStream();\n this.strm.avail_out = 0;\n\n var status = zlib_inflate.inflateInit2(\n this.strm,\n opt.windowBits\n );\n\n if (status !== c.Z_OK) {\n throw new Error(msg[status]);\n }\n\n this.header = new GZheader();\n\n zlib_inflate.inflateGetHeader(this.strm, this.header);\n}\n\n/**\n * Inflate#push(data[, mode]) -> Boolean\n * - data (Uint8Array|Array|ArrayBuffer|String): input data\n * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.\n * See constants. Skipped or `false` means Z_NO_FLUSH, `true` meansh Z_FINISH.\n *\n * Sends input data to inflate pipe, generating [[Inflate#onData]] calls with\n * new output chunks. Returns `true` on success. The last data block must have\n * mode Z_FINISH (or `true`). That will flush internal pending buffers and call\n * [[Inflate#onEnd]]. For interim explicit flushes (without ending the stream) you\n * can use mode Z_SYNC_FLUSH, keeping the decompression context.\n *\n * On fail call [[Inflate#onEnd]] with error code and return false.\n *\n * We strongly recommend to use `Uint8Array` on input for best speed (output\n * format is detected automatically). Also, don't skip last param and always\n * use the same type in your code (boolean or number). That will improve JS speed.\n *\n * For regular `Array`-s make sure all elements are [0..255].\n *\n * ##### Example\n *\n * ```javascript\n * push(chunk, false); // push one of data chunks\n * ...\n * push(chunk, true); // push last chunk\n * ```\n **/\nInflate.prototype.push = function (data, mode) {\n var strm = this.strm;\n var chunkSize = this.options.chunkSize;\n var dictionary = this.options.dictionary;\n var status, _mode;\n var next_out_utf8, tail, utf8str;\n var dict;\n\n // Flag to properly process Z_BUF_ERROR on testing inflate call\n // when we check that all output data was flushed.\n var allowBufError = false;\n\n if (this.ended) { return false; }\n _mode = (mode === ~~mode) ? mode : ((mode === true) ? c.Z_FINISH : c.Z_NO_FLUSH);\n\n // Convert data if needed\n if (typeof data === 'string') {\n // Only binary strings can be decompressed on practice\n strm.input = strings.binstring2buf(data);\n } else if (toString.call(data) === '[object ArrayBuffer]') {\n strm.input = new Uint8Array(data);\n } else {\n strm.input = data;\n }\n\n strm.next_in = 0;\n strm.avail_in = strm.input.length;\n\n do {\n if (strm.avail_out === 0) {\n strm.output = new utils.Buf8(chunkSize);\n strm.next_out = 0;\n strm.avail_out = chunkSize;\n }\n\n status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH); /* no bad return value */\n\n if (status === c.Z_NEED_DICT && dictionary) {\n // Convert data if needed\n if (typeof dictionary === 'string') {\n dict = strings.string2buf(dictionary);\n } else if (toString.call(dictionary) === '[object ArrayBuffer]') {\n dict = new Uint8Array(dictionary);\n } else {\n dict = dictionary;\n }\n\n status = zlib_inflate.inflateSetDictionary(this.strm, dict);\n\n }\n\n if (status === c.Z_BUF_ERROR && allowBufError === true) {\n status = c.Z_OK;\n allowBufError = false;\n }\n\n if (status !== c.Z_STREAM_END && status !== c.Z_OK) {\n this.onEnd(status);\n this.ended = true;\n return false;\n }\n\n if (strm.next_out) {\n if (strm.avail_out === 0 || status === c.Z_STREAM_END || (strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH))) {\n\n if (this.options.to === 'string') {\n\n next_out_utf8 = strings.utf8border(strm.output, strm.next_out);\n\n tail = strm.next_out - next_out_utf8;\n utf8str = strings.buf2string(strm.output, next_out_utf8);\n\n // move tail\n strm.next_out = tail;\n strm.avail_out = chunkSize - tail;\n if (tail) { utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0); }\n\n this.onData(utf8str);\n\n } else {\n this.onData(utils.shrinkBuf(strm.output, strm.next_out));\n }\n }\n }\n\n // When no more input data, we should check that internal inflate buffers\n // are flushed. The only way to do it when avail_out = 0 - run one more\n // inflate pass. But if output data not exists, inflate return Z_BUF_ERROR.\n // Here we set flag to process this error properly.\n //\n // NOTE. Deflate does not return error in this case and does not needs such\n // logic.\n if (strm.avail_in === 0 && strm.avail_out === 0) {\n allowBufError = true;\n }\n\n } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== c.Z_STREAM_END);\n\n if (status === c.Z_STREAM_END) {\n _mode = c.Z_FINISH;\n }\n\n // Finalize on the last chunk.\n if (_mode === c.Z_FINISH) {\n status = zlib_inflate.inflateEnd(this.strm);\n this.onEnd(status);\n this.ended = true;\n return status === c.Z_OK;\n }\n\n // callback interim results if Z_SYNC_FLUSH.\n if (_mode === c.Z_SYNC_FLUSH) {\n this.onEnd(c.Z_OK);\n strm.avail_out = 0;\n return true;\n }\n\n return true;\n};\n\n\n/**\n * Inflate#onData(chunk) -> Void\n * - chunk (Uint8Array|Array|String): ouput data. Type of array depends\n * on js engine support. When string output requested, each chunk\n * will be string.\n *\n * By default, stores data blocks in `chunks[]` property and glue\n * those in `onEnd`. Override this handler, if you need another behaviour.\n **/\nInflate.prototype.onData = function (chunk) {\n this.chunks.push(chunk);\n};\n\n\n/**\n * Inflate#onEnd(status) -> Void\n * - status (Number): inflate status. 0 (Z_OK) on success,\n * other if not.\n *\n * Called either after you tell inflate that the input stream is\n * complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH)\n * or if an error happened. By default - join collected chunks,\n * free memory and fill `results` / `err` properties.\n **/\nInflate.prototype.onEnd = function (status) {\n // On success - join\n if (status === c.Z_OK) {\n if (this.options.to === 'string') {\n // Glue & convert here, until we teach pako to send\n // utf8 alligned strings to onData\n this.result = this.chunks.join('');\n } else {\n this.result = utils.flattenChunks(this.chunks);\n }\n }\n this.chunks = [];\n this.err = status;\n this.msg = this.strm.msg;\n};\n\n\n/**\n * inflate(data[, options]) -> Uint8Array|Array|String\n * - data (Uint8Array|Array|String): input data to decompress.\n * - options (Object): zlib inflate options.\n *\n * Decompress `data` with inflate/ungzip and `options`. Autodetect\n * format via wrapper header by default. That's why we don't provide\n * separate `ungzip` method.\n *\n * Supported options are:\n *\n * - windowBits\n *\n * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n * for more information.\n *\n * Sugar (options):\n *\n * - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify\n * negative windowBits implicitly.\n * - `to` (String) - if equal to 'string', then result will be converted\n * from utf8 to utf16 (javascript) string. When string output requested,\n * chunk length can differ from `chunkSize`, depending on content.\n *\n *\n * ##### Example:\n *\n * ```javascript\n * var pako = require('pako')\n * , input = pako.deflate([1,2,3,4,5,6,7,8,9])\n * , output;\n *\n * try {\n * output = pako.inflate(input);\n * } catch (err)\n * console.log(err);\n * }\n * ```\n **/\nfunction inflate(input, options) {\n var inflator = new Inflate(options);\n\n inflator.push(input, true);\n\n // That will never happens, if you don't cheat with options :)\n if (inflator.err) { throw inflator.msg || msg[inflator.err]; }\n\n return inflator.result;\n}\n\n\n/**\n * inflateRaw(data[, options]) -> Uint8Array|Array|String\n * - data (Uint8Array|Array|String): input data to decompress.\n * - options (Object): zlib inflate options.\n *\n * The same as [[inflate]], but creates raw data, without wrapper\n * (header and adler32 crc).\n **/\nfunction inflateRaw(input, options) {\n options = options || {};\n options.raw = true;\n return inflate(input, options);\n}\n\n\n/**\n * ungzip(data[, options]) -> Uint8Array|Array|String\n * - data (Uint8Array|Array|String): input data to decompress.\n * - options (Object): zlib inflate options.\n *\n * Just shortcut to [[inflate]], because it autodetects format\n * by header.content. Done for convenience.\n **/\n\n\nexports.Inflate = Inflate;\nexports.inflate = inflate;\nexports.inflateRaw = inflateRaw;\nexports.ungzip = inflate;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/pako/lib/inflate.js\n// module id = 13\n// module chunks = 0","// String encode/decode helpers\n'use strict';\n\n\nvar utils = require('./common');\n\n\n// Quick check if we can use fast array to bin string conversion\n//\n// - apply(Array) can fail on Android 2.2\n// - apply(Uint8Array) can fail on iOS 5.1 Safary\n//\nvar STR_APPLY_OK = true;\nvar STR_APPLY_UIA_OK = true;\n\ntry { String.fromCharCode.apply(null, [ 0 ]); } catch (__) { STR_APPLY_OK = false; }\ntry { String.fromCharCode.apply(null, new Uint8Array(1)); } catch (__) { STR_APPLY_UIA_OK = false; }\n\n\n// Table with utf8 lengths (calculated by first byte of sequence)\n// Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,\n// because max possible codepoint is 0x10ffff\nvar _utf8len = new utils.Buf8(256);\nfor (var q = 0; q < 256; q++) {\n _utf8len[q] = (q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1);\n}\n_utf8len[254] = _utf8len[254] = 1; // Invalid sequence start\n\n\n// convert string to array (typed, when possible)\nexports.string2buf = function (str) {\n var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;\n\n // count binary size\n for (m_pos = 0; m_pos < str_len; m_pos++) {\n c = str.charCodeAt(m_pos);\n if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {\n c2 = str.charCodeAt(m_pos + 1);\n if ((c2 & 0xfc00) === 0xdc00) {\n c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n m_pos++;\n }\n }\n buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;\n }\n\n // allocate buffer\n buf = new utils.Buf8(buf_len);\n\n // convert\n for (i = 0, m_pos = 0; i < buf_len; m_pos++) {\n c = str.charCodeAt(m_pos);\n if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {\n c2 = str.charCodeAt(m_pos + 1);\n if ((c2 & 0xfc00) === 0xdc00) {\n c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n m_pos++;\n }\n }\n if (c < 0x80) {\n /* one byte */\n buf[i++] = c;\n } else if (c < 0x800) {\n /* two bytes */\n buf[i++] = 0xC0 | (c >>> 6);\n buf[i++] = 0x80 | (c & 0x3f);\n } else if (c < 0x10000) {\n /* three bytes */\n buf[i++] = 0xE0 | (c >>> 12);\n buf[i++] = 0x80 | (c >>> 6 & 0x3f);\n buf[i++] = 0x80 | (c & 0x3f);\n } else {\n /* four bytes */\n buf[i++] = 0xf0 | (c >>> 18);\n buf[i++] = 0x80 | (c >>> 12 & 0x3f);\n buf[i++] = 0x80 | (c >>> 6 & 0x3f);\n buf[i++] = 0x80 | (c & 0x3f);\n }\n }\n\n return buf;\n};\n\n// Helper (used in 2 places)\nfunction buf2binstring(buf, len) {\n // use fallback for big arrays to avoid stack overflow\n if (len < 65537) {\n if ((buf.subarray && STR_APPLY_UIA_OK) || (!buf.subarray && STR_APPLY_OK)) {\n return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len));\n }\n }\n\n var result = '';\n for (var i = 0; i < len; i++) {\n result += String.fromCharCode(buf[i]);\n }\n return result;\n}\n\n\n// Convert byte array to binary string\nexports.buf2binstring = function (buf) {\n return buf2binstring(buf, buf.length);\n};\n\n\n// Convert binary string (typed, when possible)\nexports.binstring2buf = function (str) {\n var buf = new utils.Buf8(str.length);\n for (var i = 0, len = buf.length; i < len; i++) {\n buf[i] = str.charCodeAt(i);\n }\n return buf;\n};\n\n\n// convert array to string\nexports.buf2string = function (buf, max) {\n var i, out, c, c_len;\n var len = max || buf.length;\n\n // Reserve max possible length (2 words per char)\n // NB: by unknown reasons, Array is significantly faster for\n // String.fromCharCode.apply than Uint16Array.\n var utf16buf = new Array(len * 2);\n\n for (out = 0, i = 0; i < len;) {\n c = buf[i++];\n // quick process ascii\n if (c < 0x80) { utf16buf[out++] = c; continue; }\n\n c_len = _utf8len[c];\n // skip 5 & 6 byte codes\n if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len - 1; continue; }\n\n // apply mask on first byte\n c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;\n // join the rest\n while (c_len > 1 && i < len) {\n c = (c << 6) | (buf[i++] & 0x3f);\n c_len--;\n }\n\n // terminated by end of string?\n if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }\n\n if (c < 0x10000) {\n utf16buf[out++] = c;\n } else {\n c -= 0x10000;\n utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff);\n utf16buf[out++] = 0xdc00 | (c & 0x3ff);\n }\n }\n\n return buf2binstring(utf16buf, out);\n};\n\n\n// Calculate max possible position in utf8 buffer,\n// that will not break sequence. If that's not possible\n// - (very small limits) return max size as is.\n//\n// buf[] - utf8 bytes array\n// max - length limit (mandatory);\nexports.utf8border = function (buf, max) {\n var pos;\n\n max = max || buf.length;\n if (max > buf.length) { max = buf.length; }\n\n // go back from last position, until start of sequence found\n pos = max - 1;\n while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }\n\n // Fuckup - very small and broken sequence,\n // return max, because we should return something anyway.\n if (pos < 0) { return max; }\n\n // If we came to start of buffer - that means vuffer is too small,\n // return max too.\n if (pos === 0) { return max; }\n\n return (pos + _utf8len[buf[pos]] > max) ? pos : max;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/pako/lib/utils/strings.js\n// module id = 14\n// module chunks = 0","'use strict';\n\n// Note: adler32 takes 12% for level 0 and 2% for level 6.\n// It doesn't worth to make additional optimizationa as in original.\n// Small size is preferable.\n\nfunction adler32(adler, buf, len, pos) {\n var s1 = (adler & 0xffff) |0,\n s2 = ((adler >>> 16) & 0xffff) |0,\n n = 0;\n\n while (len !== 0) {\n // Set limit ~ twice less than 5552, to keep\n // s2 in 31-bits, because we force signed ints.\n // in other case %= will fail.\n n = len > 2000 ? 2000 : len;\n len -= n;\n\n do {\n s1 = (s1 + buf[pos++]) |0;\n s2 = (s2 + s1) |0;\n } while (--n);\n\n s1 %= 65521;\n s2 %= 65521;\n }\n\n return (s1 | (s2 << 16)) |0;\n}\n\n\nmodule.exports = adler32;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/pako/lib/zlib/adler32.js\n// module id = 15\n// module chunks = 0","'use strict';\n\n\nmodule.exports = {\n\n /* Allowed flush values; see deflate() and inflate() below for details */\n Z_NO_FLUSH: 0,\n Z_PARTIAL_FLUSH: 1,\n Z_SYNC_FLUSH: 2,\n Z_FULL_FLUSH: 3,\n Z_FINISH: 4,\n Z_BLOCK: 5,\n Z_TREES: 6,\n\n /* Return codes for the compression/decompression functions. Negative values\n * are errors, positive values are used for special but normal events.\n */\n Z_OK: 0,\n Z_STREAM_END: 1,\n Z_NEED_DICT: 2,\n Z_ERRNO: -1,\n Z_STREAM_ERROR: -2,\n Z_DATA_ERROR: -3,\n //Z_MEM_ERROR: -4,\n Z_BUF_ERROR: -5,\n //Z_VERSION_ERROR: -6,\n\n /* compression levels */\n Z_NO_COMPRESSION: 0,\n Z_BEST_SPEED: 1,\n Z_BEST_COMPRESSION: 9,\n Z_DEFAULT_COMPRESSION: -1,\n\n\n Z_FILTERED: 1,\n Z_HUFFMAN_ONLY: 2,\n Z_RLE: 3,\n Z_FIXED: 4,\n Z_DEFAULT_STRATEGY: 0,\n\n /* Possible values of the data_type field (though see inflate()) */\n Z_BINARY: 0,\n Z_TEXT: 1,\n //Z_ASCII: 1, // = Z_TEXT (deprecated)\n Z_UNKNOWN: 2,\n\n /* The deflate compression method */\n Z_DEFLATED: 8\n //Z_NULL: null // Use -1 or null inline, depending on var type\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/pako/lib/zlib/constants.js\n// module id = 16\n// module chunks = 0","'use strict';\n\n// Note: we can't get significant speed boost here.\n// So write code to minimize size - no pregenerated tables\n// and array tools dependencies.\n\n\n// Use ordinary array, since untyped makes no boost here\nfunction makeTable() {\n var c, table = [];\n\n for (var n = 0; n < 256; n++) {\n c = n;\n for (var k = 0; k < 8; k++) {\n c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));\n }\n table[n] = c;\n }\n\n return table;\n}\n\n// Create table on load. Just 255 signed longs. Not a problem.\nvar crcTable = makeTable();\n\n\nfunction crc32(crc, buf, len, pos) {\n var t = crcTable,\n end = pos + len;\n\n crc ^= -1;\n\n for (var i = pos; i < end; i++) {\n crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];\n }\n\n return (crc ^ (-1)); // >>> 0;\n}\n\n\nmodule.exports = crc32;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/pako/lib/zlib/crc32.js\n// module id = 17\n// module chunks = 0","'use strict';\n\n\nfunction GZheader() {\n /* true if compressed data believed to be text */\n this.text = 0;\n /* modification time */\n this.time = 0;\n /* extra flags (not used when writing a gzip file) */\n this.xflags = 0;\n /* operating system */\n this.os = 0;\n /* pointer to extra field or Z_NULL if none */\n this.extra = null;\n /* extra field length (valid if extra != Z_NULL) */\n this.extra_len = 0; // Actually, we don't need it in JS,\n // but leave for few code modifications\n\n //\n // Setup limits is not necessary because in js we should not preallocate memory\n // for inflate use constant limit in 65536 bytes\n //\n\n /* space at extra (only when reading header) */\n // this.extra_max = 0;\n /* pointer to zero-terminated file name or Z_NULL */\n this.name = '';\n /* space at name (only when reading header) */\n // this.name_max = 0;\n /* pointer to zero-terminated comment or Z_NULL */\n this.comment = '';\n /* space at comment (only when reading header) */\n // this.comm_max = 0;\n /* true if there was or will be a header crc */\n this.hcrc = 0;\n /* true when done reading gzip header (not used when writing a gzip file) */\n this.done = false;\n}\n\nmodule.exports = GZheader;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/pako/lib/zlib/gzheader.js\n// module id = 18\n// module chunks = 0","'use strict';\n\n// See state defs from inflate.js\nvar BAD = 30; /* got a data error -- remain here until reset */\nvar TYPE = 12; /* i: waiting for type bits, including last-flag bit */\n\n/*\n Decode literal, length, and distance codes and write out the resulting\n literal and match bytes until either not enough input or output is\n available, an end-of-block is encountered, or a data error is encountered.\n When large enough input and output buffers are supplied to inflate(), for\n example, a 16K input buffer and a 64K output buffer, more than 95% of the\n inflate execution time is spent in this routine.\n\n Entry assumptions:\n\n state.mode === LEN\n strm.avail_in >= 6\n strm.avail_out >= 258\n start >= strm.avail_out\n state.bits < 8\n\n On return, state.mode is one of:\n\n LEN -- ran out of enough output space or enough available input\n TYPE -- reached end of block code, inflate() to interpret next block\n BAD -- error in block data\n\n Notes:\n\n - The maximum input bits used by a length/distance pair is 15 bits for the\n length code, 5 bits for the length extra, 15 bits for the distance code,\n and 13 bits for the distance extra. This totals 48 bits, or six bytes.\n Therefore if strm.avail_in >= 6, then there is enough input to avoid\n checking for available input while decoding.\n\n - The maximum bytes that a single length/distance pair can output is 258\n bytes, which is the maximum length that can be coded. inflate_fast()\n requires strm.avail_out >= 258 for each loop to avoid checking for\n output space.\n */\nmodule.exports = function inflate_fast(strm, start) {\n var state;\n var _in; /* local strm.input */\n var last; /* have enough input while in < last */\n var _out; /* local strm.output */\n var beg; /* inflate()'s initial strm.output */\n var end; /* while out < end, enough space available */\n//#ifdef INFLATE_STRICT\n var dmax; /* maximum distance from zlib header */\n//#endif\n var wsize; /* window size or zero if not using window */\n var whave; /* valid bytes in the window */\n var wnext; /* window write index */\n // Use `s_window` instead `window`, avoid conflict with instrumentation tools\n var s_window; /* allocated sliding window, if wsize != 0 */\n var hold; /* local strm.hold */\n var bits; /* local strm.bits */\n var lcode; /* local strm.lencode */\n var dcode; /* local strm.distcode */\n var lmask; /* mask for first level of length codes */\n var dmask; /* mask for first level of distance codes */\n var here; /* retrieved table entry */\n var op; /* code bits, operation, extra bits, or */\n /* window position, window bytes to copy */\n var len; /* match length, unused bytes */\n var dist; /* match distance */\n var from; /* where to copy match from */\n var from_source;\n\n\n var input, output; // JS specific, because we have no pointers\n\n /* copy state to local variables */\n state = strm.state;\n //here = state.here;\n _in = strm.next_in;\n input = strm.input;\n last = _in + (strm.avail_in - 5);\n _out = strm.next_out;\n output = strm.output;\n beg = _out - (start - strm.avail_out);\n end = _out + (strm.avail_out - 257);\n//#ifdef INFLATE_STRICT\n dmax = state.dmax;\n//#endif\n wsize = state.wsize;\n whave = state.whave;\n wnext = state.wnext;\n s_window = state.window;\n hold = state.hold;\n bits = state.bits;\n lcode = state.lencode;\n dcode = state.distcode;\n lmask = (1 << state.lenbits) - 1;\n dmask = (1 << state.distbits) - 1;\n\n\n /* decode literals and length/distances until end-of-block or not enough\n input data or output space */\n\n top:\n do {\n if (bits < 15) {\n hold += input[_in++] << bits;\n bits += 8;\n hold += input[_in++] << bits;\n bits += 8;\n }\n\n here = lcode[hold & lmask];\n\n dolen:\n for (;;) { // Goto emulation\n op = here >>> 24/*here.bits*/;\n hold >>>= op;\n bits -= op;\n op = (here >>> 16) & 0xff/*here.op*/;\n if (op === 0) { /* literal */\n //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?\n // \"inflate: literal '%c'\\n\" :\n // \"inflate: literal 0x%02x\\n\", here.val));\n output[_out++] = here & 0xffff/*here.val*/;\n }\n else if (op & 16) { /* length base */\n len = here & 0xffff/*here.val*/;\n op &= 15; /* number of extra bits */\n if (op) {\n if (bits < op) {\n hold += input[_in++] << bits;\n bits += 8;\n }\n len += hold & ((1 << op) - 1);\n hold >>>= op;\n bits -= op;\n }\n //Tracevv((stderr, \"inflate: length %u\\n\", len));\n if (bits < 15) {\n hold += input[_in++] << bits;\n bits += 8;\n hold += input[_in++] << bits;\n bits += 8;\n }\n here = dcode[hold & dmask];\n\n dodist:\n for (;;) { // goto emulation\n op = here >>> 24/*here.bits*/;\n hold >>>= op;\n bits -= op;\n op = (here >>> 16) & 0xff/*here.op*/;\n\n if (op & 16) { /* distance base */\n dist = here & 0xffff/*here.val*/;\n op &= 15; /* number of extra bits */\n if (bits < op) {\n hold += input[_in++] << bits;\n bits += 8;\n if (bits < op) {\n hold += input[_in++] << bits;\n bits += 8;\n }\n }\n dist += hold & ((1 << op) - 1);\n//#ifdef INFLATE_STRICT\n if (dist > dmax) {\n strm.msg = 'invalid distance too far back';\n state.mode = BAD;\n break top;\n }\n//#endif\n hold >>>= op;\n bits -= op;\n //Tracevv((stderr, \"inflate: distance %u\\n\", dist));\n op = _out - beg; /* max distance in output */\n if (dist > op) { /* see if copy from window */\n op = dist - op; /* distance back in window */\n if (op > whave) {\n if (state.sane) {\n strm.msg = 'invalid distance too far back';\n state.mode = BAD;\n break top;\n }\n\n// (!) This block is disabled in zlib defailts,\n// don't enable it for binary compatibility\n//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR\n// if (len <= op - whave) {\n// do {\n// output[_out++] = 0;\n// } while (--len);\n// continue top;\n// }\n// len -= op - whave;\n// do {\n// output[_out++] = 0;\n// } while (--op > whave);\n// if (op === 0) {\n// from = _out - dist;\n// do {\n// output[_out++] = output[from++];\n// } while (--len);\n// continue top;\n// }\n//#endif\n }\n from = 0; // window index\n from_source = s_window;\n if (wnext === 0) { /* very common case */\n from += wsize - op;\n if (op < len) { /* some from window */\n len -= op;\n do {\n output[_out++] = s_window[from++];\n } while (--op);\n from = _out - dist; /* rest from output */\n from_source = output;\n }\n }\n else if (wnext < op) { /* wrap around window */\n from += wsize + wnext - op;\n op -= wnext;\n if (op < len) { /* some from end of window */\n len -= op;\n do {\n output[_out++] = s_window[from++];\n } while (--op);\n from = 0;\n if (wnext < len) { /* some from start of window */\n op = wnext;\n len -= op;\n do {\n output[_out++] = s_window[from++];\n } while (--op);\n from = _out - dist; /* rest from output */\n from_source = output;\n }\n }\n }\n else { /* contiguous in window */\n from += wnext - op;\n if (op < len) { /* some from window */\n len -= op;\n do {\n output[_out++] = s_window[from++];\n } while (--op);\n from = _out - dist; /* rest from output */\n from_source = output;\n }\n }\n while (len > 2) {\n output[_out++] = from_source[from++];\n output[_out++] = from_source[from++];\n output[_out++] = from_source[from++];\n len -= 3;\n }\n if (len) {\n output[_out++] = from_source[from++];\n if (len > 1) {\n output[_out++] = from_source[from++];\n }\n }\n }\n else {\n from = _out - dist; /* copy direct from output */\n do { /* minimum length is three */\n output[_out++] = output[from++];\n output[_out++] = output[from++];\n output[_out++] = output[from++];\n len -= 3;\n } while (len > 2);\n if (len) {\n output[_out++] = output[from++];\n if (len > 1) {\n output[_out++] = output[from++];\n }\n }\n }\n }\n else if ((op & 64) === 0) { /* 2nd level distance code */\n here = dcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];\n continue dodist;\n }\n else {\n strm.msg = 'invalid distance code';\n state.mode = BAD;\n break top;\n }\n\n break; // need to emulate goto via \"continue\"\n }\n }\n else if ((op & 64) === 0) { /* 2nd level length code */\n here = lcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];\n continue dolen;\n }\n else if (op & 32) { /* end-of-block */\n //Tracevv((stderr, \"inflate: end of block\\n\"));\n state.mode = TYPE;\n break top;\n }\n else {\n strm.msg = 'invalid literal/length code';\n state.mode = BAD;\n break top;\n }\n\n break; // need to emulate goto via \"continue\"\n }\n } while (_in < last && _out < end);\n\n /* return unused bytes (on entry, bits < 8, so in won't go too far back) */\n len = bits >> 3;\n _in -= len;\n bits -= len << 3;\n hold &= (1 << bits) - 1;\n\n /* update state and return */\n strm.next_in = _in;\n strm.next_out = _out;\n strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last));\n strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end));\n state.hold = hold;\n state.bits = bits;\n return;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/pako/lib/zlib/inffast.js\n// module id = 19\n// module chunks = 0","'use strict';\n\n\nvar utils = require('../utils/common');\nvar adler32 = require('./adler32');\nvar crc32 = require('./crc32');\nvar inflate_fast = require('./inffast');\nvar inflate_table = require('./inftrees');\n\nvar CODES = 0;\nvar LENS = 1;\nvar DISTS = 2;\n\n/* Public constants ==========================================================*/\n/* ===========================================================================*/\n\n\n/* Allowed flush values; see deflate() and inflate() below for details */\n//var Z_NO_FLUSH = 0;\n//var Z_PARTIAL_FLUSH = 1;\n//var Z_SYNC_FLUSH = 2;\n//var Z_FULL_FLUSH = 3;\nvar Z_FINISH = 4;\nvar Z_BLOCK = 5;\nvar Z_TREES = 6;\n\n\n/* Return codes for the compression/decompression functions. Negative values\n * are errors, positive values are used for special but normal events.\n */\nvar Z_OK = 0;\nvar Z_STREAM_END = 1;\nvar Z_NEED_DICT = 2;\n//var Z_ERRNO = -1;\nvar Z_STREAM_ERROR = -2;\nvar Z_DATA_ERROR = -3;\nvar Z_MEM_ERROR = -4;\nvar Z_BUF_ERROR = -5;\n//var Z_VERSION_ERROR = -6;\n\n/* The deflate compression method */\nvar Z_DEFLATED = 8;\n\n\n/* STATES ====================================================================*/\n/* ===========================================================================*/\n\n\nvar HEAD = 1; /* i: waiting for magic header */\nvar FLAGS = 2; /* i: waiting for method and flags (gzip) */\nvar TIME = 3; /* i: waiting for modification time (gzip) */\nvar OS = 4; /* i: waiting for extra flags and operating system (gzip) */\nvar EXLEN = 5; /* i: waiting for extra length (gzip) */\nvar EXTRA = 6; /* i: waiting for extra bytes (gzip) */\nvar NAME = 7; /* i: waiting for end of file name (gzip) */\nvar COMMENT = 8; /* i: waiting for end of comment (gzip) */\nvar HCRC = 9; /* i: waiting for header crc (gzip) */\nvar DICTID = 10; /* i: waiting for dictionary check value */\nvar DICT = 11; /* waiting for inflateSetDictionary() call */\nvar TYPE = 12; /* i: waiting for type bits, including last-flag bit */\nvar TYPEDO = 13; /* i: same, but skip check to exit inflate on new block */\nvar STORED = 14; /* i: waiting for stored size (length and complement) */\nvar COPY_ = 15; /* i/o: same as COPY below, but only first time in */\nvar COPY = 16; /* i/o: waiting for input or output to copy stored block */\nvar TABLE = 17; /* i: waiting for dynamic block table lengths */\nvar LENLENS = 18; /* i: waiting for code length code lengths */\nvar CODELENS = 19; /* i: waiting for length/lit and distance code lengths */\nvar LEN_ = 20; /* i: same as LEN below, but only first time in */\nvar LEN = 21; /* i: waiting for length/lit/eob code */\nvar LENEXT = 22; /* i: waiting for length extra bits */\nvar DIST = 23; /* i: waiting for distance code */\nvar DISTEXT = 24; /* i: waiting for distance extra bits */\nvar MATCH = 25; /* o: waiting for output space to copy string */\nvar LIT = 26; /* o: waiting for output space to write literal */\nvar CHECK = 27; /* i: waiting for 32-bit check value */\nvar LENGTH = 28; /* i: waiting for 32-bit length (gzip) */\nvar DONE = 29; /* finished check, done -- remain here until reset */\nvar BAD = 30; /* got a data error -- remain here until reset */\nvar MEM = 31; /* got an inflate() memory error -- remain here until reset */\nvar SYNC = 32; /* looking for synchronization bytes to restart inflate() */\n\n/* ===========================================================================*/\n\n\n\nvar ENOUGH_LENS = 852;\nvar ENOUGH_DISTS = 592;\n//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);\n\nvar MAX_WBITS = 15;\n/* 32K LZ77 window */\nvar DEF_WBITS = MAX_WBITS;\n\n\nfunction zswap32(q) {\n return (((q >>> 24) & 0xff) +\n ((q >>> 8) & 0xff00) +\n ((q & 0xff00) << 8) +\n ((q & 0xff) << 24));\n}\n\n\nfunction InflateState() {\n this.mode = 0; /* current inflate mode */\n this.last = false; /* true if processing last block */\n this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */\n this.havedict = false; /* true if dictionary provided */\n this.flags = 0; /* gzip header method and flags (0 if zlib) */\n this.dmax = 0; /* zlib header max distance (INFLATE_STRICT) */\n this.check = 0; /* protected copy of check value */\n this.total = 0; /* protected copy of output count */\n // TODO: may be {}\n this.head = null; /* where to save gzip header information */\n\n /* sliding window */\n this.wbits = 0; /* log base 2 of requested window size */\n this.wsize = 0; /* window size or zero if not using window */\n this.whave = 0; /* valid bytes in the window */\n this.wnext = 0; /* window write index */\n this.window = null; /* allocated sliding window, if needed */\n\n /* bit accumulator */\n this.hold = 0; /* input bit accumulator */\n this.bits = 0; /* number of bits in \"in\" */\n\n /* for string and stored block copying */\n this.length = 0; /* literal or length of data to copy */\n this.offset = 0; /* distance back to copy string from */\n\n /* for table and code decoding */\n this.extra = 0; /* extra bits needed */\n\n /* fixed and dynamic code tables */\n this.lencode = null; /* starting table for length/literal codes */\n this.distcode = null; /* starting table for distance codes */\n this.lenbits = 0; /* index bits for lencode */\n this.distbits = 0; /* index bits for distcode */\n\n /* dynamic table building */\n this.ncode = 0; /* number of code length code lengths */\n this.nlen = 0; /* number of length code lengths */\n this.ndist = 0; /* number of distance code lengths */\n this.have = 0; /* number of code lengths in lens[] */\n this.next = null; /* next available space in codes[] */\n\n this.lens = new utils.Buf16(320); /* temporary storage for code lengths */\n this.work = new utils.Buf16(288); /* work area for code table building */\n\n /*\n because we don't have pointers in js, we use lencode and distcode directly\n as buffers so we don't need codes\n */\n //this.codes = new utils.Buf32(ENOUGH); /* space for code tables */\n this.lendyn = null; /* dynamic table for length/literal codes (JS specific) */\n this.distdyn = null; /* dynamic table for distance codes (JS specific) */\n this.sane = 0; /* if false, allow invalid distance too far */\n this.back = 0; /* bits back of last unprocessed length/lit */\n this.was = 0; /* initial length of match */\n}\n\nfunction inflateResetKeep(strm) {\n var state;\n\n if (!strm || !strm.state) { return Z_STREAM_ERROR; }\n state = strm.state;\n strm.total_in = strm.total_out = state.total = 0;\n strm.msg = ''; /*Z_NULL*/\n if (state.wrap) { /* to support ill-conceived Java test suite */\n strm.adler = state.wrap & 1;\n }\n state.mode = HEAD;\n state.last = 0;\n state.havedict = 0;\n state.dmax = 32768;\n state.head = null/*Z_NULL*/;\n state.hold = 0;\n state.bits = 0;\n //state.lencode = state.distcode = state.next = state.codes;\n state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS);\n state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS);\n\n state.sane = 1;\n state.back = -1;\n //Tracev((stderr, \"inflate: reset\\n\"));\n return Z_OK;\n}\n\nfunction inflateReset(strm) {\n var state;\n\n if (!strm || !strm.state) { return Z_STREAM_ERROR; }\n state = strm.state;\n state.wsize = 0;\n state.whave = 0;\n state.wnext = 0;\n return inflateResetKeep(strm);\n\n}\n\nfunction inflateReset2(strm, windowBits) {\n var wrap;\n var state;\n\n /* get the state */\n if (!strm || !strm.state) { return Z_STREAM_ERROR; }\n state = strm.state;\n\n /* extract wrap request from windowBits parameter */\n if (windowBits < 0) {\n wrap = 0;\n windowBits = -windowBits;\n }\n else {\n wrap = (windowBits >> 4) + 1;\n if (windowBits < 48) {\n windowBits &= 15;\n }\n }\n\n /* set number of window bits, free window if different */\n if (windowBits && (windowBits < 8 || windowBits > 15)) {\n return Z_STREAM_ERROR;\n }\n if (state.window !== null && state.wbits !== windowBits) {\n state.window = null;\n }\n\n /* update state and reset the rest of it */\n state.wrap = wrap;\n state.wbits = windowBits;\n return inflateReset(strm);\n}\n\nfunction inflateInit2(strm, windowBits) {\n var ret;\n var state;\n\n if (!strm) { return Z_STREAM_ERROR; }\n //strm.msg = Z_NULL; /* in case we return an error */\n\n state = new InflateState();\n\n //if (state === Z_NULL) return Z_MEM_ERROR;\n //Tracev((stderr, \"inflate: allocated\\n\"));\n strm.state = state;\n state.window = null/*Z_NULL*/;\n ret = inflateReset2(strm, windowBits);\n if (ret !== Z_OK) {\n strm.state = null/*Z_NULL*/;\n }\n return ret;\n}\n\nfunction inflateInit(strm) {\n return inflateInit2(strm, DEF_WBITS);\n}\n\n\n/*\n Return state with length and distance decoding tables and index sizes set to\n fixed code decoding. Normally this returns fixed tables from inffixed.h.\n If BUILDFIXED is defined, then instead this routine builds the tables the\n first time it's called, and returns those tables the first time and\n thereafter. This reduces the size of the code by about 2K bytes, in\n exchange for a little execution time. However, BUILDFIXED should not be\n used for threaded applications, since the rewriting of the tables and virgin\n may not be thread-safe.\n */\nvar virgin = true;\n\nvar lenfix, distfix; // We have no pointers in JS, so keep tables separate\n\nfunction fixedtables(state) {\n /* build fixed huffman tables if first call (may not be thread safe) */\n if (virgin) {\n var sym;\n\n lenfix = new utils.Buf32(512);\n distfix = new utils.Buf32(32);\n\n /* literal/length table */\n sym = 0;\n while (sym < 144) { state.lens[sym++] = 8; }\n while (sym < 256) { state.lens[sym++] = 9; }\n while (sym < 280) { state.lens[sym++] = 7; }\n while (sym < 288) { state.lens[sym++] = 8; }\n\n inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });\n\n /* distance table */\n sym = 0;\n while (sym < 32) { state.lens[sym++] = 5; }\n\n inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });\n\n /* do this just once */\n virgin = false;\n }\n\n state.lencode = lenfix;\n state.lenbits = 9;\n state.distcode = distfix;\n state.distbits = 5;\n}\n\n\n/*\n Update the window with the last wsize (normally 32K) bytes written before\n returning. If window does not exist yet, create it. This is only called\n when a window is already in use, or when output has been written during this\n inflate call, but the end of the deflate stream has not been reached yet.\n It is also called to create a window for dictionary data when a dictionary\n is loaded.\n\n Providing output buffers larger than 32K to inflate() should provide a speed\n advantage, since only the last 32K of output is copied to the sliding window\n upon return from inflate(), and since all distances after the first 32K of\n output will fall in the output data, making match copies simpler and faster.\n The advantage may be dependent on the size of the processor's data caches.\n */\nfunction updatewindow(strm, src, end, copy) {\n var dist;\n var state = strm.state;\n\n /* if it hasn't been done already, allocate space for the window */\n if (state.window === null) {\n state.wsize = 1 << state.wbits;\n state.wnext = 0;\n state.whave = 0;\n\n state.window = new utils.Buf8(state.wsize);\n }\n\n /* copy state->wsize or less output bytes into the circular window */\n if (copy >= state.wsize) {\n utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0);\n state.wnext = 0;\n state.whave = state.wsize;\n }\n else {\n dist = state.wsize - state.wnext;\n if (dist > copy) {\n dist = copy;\n }\n //zmemcpy(state->window + state->wnext, end - copy, dist);\n utils.arraySet(state.window, src, end - copy, dist, state.wnext);\n copy -= dist;\n if (copy) {\n //zmemcpy(state->window, end - copy, copy);\n utils.arraySet(state.window, src, end - copy, copy, 0);\n state.wnext = copy;\n state.whave = state.wsize;\n }\n else {\n state.wnext += dist;\n if (state.wnext === state.wsize) { state.wnext = 0; }\n if (state.whave < state.wsize) { state.whave += dist; }\n }\n }\n return 0;\n}\n\nfunction inflate(strm, flush) {\n var state;\n var input, output; // input/output buffers\n var next; /* next input INDEX */\n var put; /* next output INDEX */\n var have, left; /* available input and output */\n var hold; /* bit buffer */\n var bits; /* bits in bit buffer */\n var _in, _out; /* save starting available input and output */\n var copy; /* number of stored or match bytes to copy */\n var from; /* where to copy match bytes from */\n var from_source;\n var here = 0; /* current decoding table entry */\n var here_bits, here_op, here_val; // paked \"here\" denormalized (JS specific)\n //var last; /* parent table entry */\n var last_bits, last_op, last_val; // paked \"last\" denormalized (JS specific)\n var len; /* length to copy for repeats, bits to drop */\n var ret; /* return code */\n var hbuf = new utils.Buf8(4); /* buffer for gzip header crc calculation */\n var opts;\n\n var n; // temporary var for NEED_BITS\n\n var order = /* permutation of code lengths */\n [ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ];\n\n\n if (!strm || !strm.state || !strm.output ||\n (!strm.input && strm.avail_in !== 0)) {\n return Z_STREAM_ERROR;\n }\n\n state = strm.state;\n if (state.mode === TYPE) { state.mode = TYPEDO; } /* skip check */\n\n\n //--- LOAD() ---\n put = strm.next_out;\n output = strm.output;\n left = strm.avail_out;\n next = strm.next_in;\n input = strm.input;\n have = strm.avail_in;\n hold = state.hold;\n bits = state.bits;\n //---\n\n _in = have;\n _out = left;\n ret = Z_OK;\n\n inf_leave: // goto emulation\n for (;;) {\n switch (state.mode) {\n case HEAD:\n if (state.wrap === 0) {\n state.mode = TYPEDO;\n break;\n }\n //=== NEEDBITS(16);\n while (bits < 16) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if ((state.wrap & 2) && hold === 0x8b1f) { /* gzip header */\n state.check = 0/*crc32(0L, Z_NULL, 0)*/;\n //=== CRC2(state.check, hold);\n hbuf[0] = hold & 0xff;\n hbuf[1] = (hold >>> 8) & 0xff;\n state.check = crc32(state.check, hbuf, 2, 0);\n //===//\n\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = FLAGS;\n break;\n }\n state.flags = 0; /* expect zlib header */\n if (state.head) {\n state.head.done = false;\n }\n if (!(state.wrap & 1) || /* check if zlib header allowed */\n (((hold & 0xff)/*BITS(8)*/ << 8) + (hold >> 8)) % 31) {\n strm.msg = 'incorrect header check';\n state.mode = BAD;\n break;\n }\n if ((hold & 0x0f)/*BITS(4)*/ !== Z_DEFLATED) {\n strm.msg = 'unknown compression method';\n state.mode = BAD;\n break;\n }\n //--- DROPBITS(4) ---//\n hold >>>= 4;\n bits -= 4;\n //---//\n len = (hold & 0x0f)/*BITS(4)*/ + 8;\n if (state.wbits === 0) {\n state.wbits = len;\n }\n else if (len > state.wbits) {\n strm.msg = 'invalid window size';\n state.mode = BAD;\n break;\n }\n state.dmax = 1 << len;\n //Tracev((stderr, \"inflate: zlib header ok\\n\"));\n strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;\n state.mode = hold & 0x200 ? DICTID : TYPE;\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n break;\n case FLAGS:\n //=== NEEDBITS(16); */\n while (bits < 16) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.flags = hold;\n if ((state.flags & 0xff) !== Z_DEFLATED) {\n strm.msg = 'unknown compression method';\n state.mode = BAD;\n break;\n }\n if (state.flags & 0xe000) {\n strm.msg = 'unknown header flags set';\n state.mode = BAD;\n break;\n }\n if (state.head) {\n state.head.text = ((hold >> 8) & 1);\n }\n if (state.flags & 0x0200) {\n //=== CRC2(state.check, hold);\n hbuf[0] = hold & 0xff;\n hbuf[1] = (hold >>> 8) & 0xff;\n state.check = crc32(state.check, hbuf, 2, 0);\n //===//\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = TIME;\n /* falls through */\n case TIME:\n //=== NEEDBITS(32); */\n while (bits < 32) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if (state.head) {\n state.head.time = hold;\n }\n if (state.flags & 0x0200) {\n //=== CRC4(state.check, hold)\n hbuf[0] = hold & 0xff;\n hbuf[1] = (hold >>> 8) & 0xff;\n hbuf[2] = (hold >>> 16) & 0xff;\n hbuf[3] = (hold >>> 24) & 0xff;\n state.check = crc32(state.check, hbuf, 4, 0);\n //===\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = OS;\n /* falls through */\n case OS:\n //=== NEEDBITS(16); */\n while (bits < 16) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if (state.head) {\n state.head.xflags = (hold & 0xff);\n state.head.os = (hold >> 8);\n }\n if (state.flags & 0x0200) {\n //=== CRC2(state.check, hold);\n hbuf[0] = hold & 0xff;\n hbuf[1] = (hold >>> 8) & 0xff;\n state.check = crc32(state.check, hbuf, 2, 0);\n //===//\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = EXLEN;\n /* falls through */\n case EXLEN:\n if (state.flags & 0x0400) {\n //=== NEEDBITS(16); */\n while (bits < 16) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.length = hold;\n if (state.head) {\n state.head.extra_len = hold;\n }\n if (state.flags & 0x0200) {\n //=== CRC2(state.check, hold);\n hbuf[0] = hold & 0xff;\n hbuf[1] = (hold >>> 8) & 0xff;\n state.check = crc32(state.check, hbuf, 2, 0);\n //===//\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n }\n else if (state.head) {\n state.head.extra = null/*Z_NULL*/;\n }\n state.mode = EXTRA;\n /* falls through */\n case EXTRA:\n if (state.flags & 0x0400) {\n copy = state.length;\n if (copy > have) { copy = have; }\n if (copy) {\n if (state.head) {\n len = state.head.extra_len - state.length;\n if (!state.head.extra) {\n // Use untyped array for more conveniend processing later\n state.head.extra = new Array(state.head.extra_len);\n }\n utils.arraySet(\n state.head.extra,\n input,\n next,\n // extra field is limited to 65536 bytes\n // - no need for additional size check\n copy,\n /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/\n len\n );\n //zmemcpy(state.head.extra + len, next,\n // len + copy > state.head.extra_max ?\n // state.head.extra_max - len : copy);\n }\n if (state.flags & 0x0200) {\n state.check = crc32(state.check, input, copy, next);\n }\n have -= copy;\n next += copy;\n state.length -= copy;\n }\n if (state.length) { break inf_leave; }\n }\n state.length = 0;\n state.mode = NAME;\n /* falls through */\n case NAME:\n if (state.flags & 0x0800) {\n if (have === 0) { break inf_leave; }\n copy = 0;\n do {\n // TODO: 2 or 1 bytes?\n len = input[next + copy++];\n /* use constant limit because in js we should not preallocate memory */\n if (state.head && len &&\n (state.length < 65536 /*state.head.name_max*/)) {\n state.head.name += String.fromCharCode(len);\n }\n } while (len && copy < have);\n\n if (state.flags & 0x0200) {\n state.check = crc32(state.check, input, copy, next);\n }\n have -= copy;\n next += copy;\n if (len) { break inf_leave; }\n }\n else if (state.head) {\n state.head.name = null;\n }\n state.length = 0;\n state.mode = COMMENT;\n /* falls through */\n case COMMENT:\n if (state.flags & 0x1000) {\n if (have === 0) { break inf_leave; }\n copy = 0;\n do {\n len = input[next + copy++];\n /* use constant limit because in js we should not preallocate memory */\n if (state.head && len &&\n (state.length < 65536 /*state.head.comm_max*/)) {\n state.head.comment += String.fromCharCode(len);\n }\n } while (len && copy < have);\n if (state.flags & 0x0200) {\n state.check = crc32(state.check, input, copy, next);\n }\n have -= copy;\n next += copy;\n if (len) { break inf_leave; }\n }\n else if (state.head) {\n state.head.comment = null;\n }\n state.mode = HCRC;\n /* falls through */\n case HCRC:\n if (state.flags & 0x0200) {\n //=== NEEDBITS(16); */\n while (bits < 16) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if (hold !== (state.check & 0xffff)) {\n strm.msg = 'header crc mismatch';\n state.mode = BAD;\n break;\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n }\n if (state.head) {\n state.head.hcrc = ((state.flags >> 9) & 1);\n state.head.done = true;\n }\n strm.adler = state.check = 0;\n state.mode = TYPE;\n break;\n case DICTID:\n //=== NEEDBITS(32); */\n while (bits < 32) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n strm.adler = state.check = zswap32(hold);\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = DICT;\n /* falls through */\n case DICT:\n if (state.havedict === 0) {\n //--- RESTORE() ---\n strm.next_out = put;\n strm.avail_out = left;\n strm.next_in = next;\n strm.avail_in = have;\n state.hold = hold;\n state.bits = bits;\n //---\n return Z_NEED_DICT;\n }\n strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;\n state.mode = TYPE;\n /* falls through */\n case TYPE:\n if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave; }\n /* falls through */\n case TYPEDO:\n if (state.last) {\n //--- BYTEBITS() ---//\n hold >>>= bits & 7;\n bits -= bits & 7;\n //---//\n state.mode = CHECK;\n break;\n }\n //=== NEEDBITS(3); */\n while (bits < 3) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.last = (hold & 0x01)/*BITS(1)*/;\n //--- DROPBITS(1) ---//\n hold >>>= 1;\n bits -= 1;\n //---//\n\n switch ((hold & 0x03)/*BITS(2)*/) {\n case 0: /* stored block */\n //Tracev((stderr, \"inflate: stored block%s\\n\",\n // state.last ? \" (last)\" : \"\"));\n state.mode = STORED;\n break;\n case 1: /* fixed block */\n fixedtables(state);\n //Tracev((stderr, \"inflate: fixed codes block%s\\n\",\n // state.last ? \" (last)\" : \"\"));\n state.mode = LEN_; /* decode codes */\n if (flush === Z_TREES) {\n //--- DROPBITS(2) ---//\n hold >>>= 2;\n bits -= 2;\n //---//\n break inf_leave;\n }\n break;\n case 2: /* dynamic block */\n //Tracev((stderr, \"inflate: dynamic codes block%s\\n\",\n // state.last ? \" (last)\" : \"\"));\n state.mode = TABLE;\n break;\n case 3:\n strm.msg = 'invalid block type';\n state.mode = BAD;\n }\n //--- DROPBITS(2) ---//\n hold >>>= 2;\n bits -= 2;\n //---//\n break;\n case STORED:\n //--- BYTEBITS() ---// /* go to byte boundary */\n hold >>>= bits & 7;\n bits -= bits & 7;\n //---//\n //=== NEEDBITS(32); */\n while (bits < 32) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) {\n strm.msg = 'invalid stored block lengths';\n state.mode = BAD;\n break;\n }\n state.length = hold & 0xffff;\n //Tracev((stderr, \"inflate: stored length %u\\n\",\n // state.length));\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = COPY_;\n if (flush === Z_TREES) { break inf_leave; }\n /* falls through */\n case COPY_:\n state.mode = COPY;\n /* falls through */\n case COPY:\n copy = state.length;\n if (copy) {\n if (copy > have) { copy = have; }\n if (copy > left) { copy = left; }\n if (copy === 0) { break inf_leave; }\n //--- zmemcpy(put, next, copy); ---\n utils.arraySet(output, input, next, copy, put);\n //---//\n have -= copy;\n next += copy;\n left -= copy;\n put += copy;\n state.length -= copy;\n break;\n }\n //Tracev((stderr, \"inflate: stored end\\n\"));\n state.mode = TYPE;\n break;\n case TABLE:\n //=== NEEDBITS(14); */\n while (bits < 14) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.nlen = (hold & 0x1f)/*BITS(5)*/ + 257;\n //--- DROPBITS(5) ---//\n hold >>>= 5;\n bits -= 5;\n //---//\n state.ndist = (hold & 0x1f)/*BITS(5)*/ + 1;\n //--- DROPBITS(5) ---//\n hold >>>= 5;\n bits -= 5;\n //---//\n state.ncode = (hold & 0x0f)/*BITS(4)*/ + 4;\n //--- DROPBITS(4) ---//\n hold >>>= 4;\n bits -= 4;\n //---//\n//#ifndef PKZIP_BUG_WORKAROUND\n if (state.nlen > 286 || state.ndist > 30) {\n strm.msg = 'too many length or distance symbols';\n state.mode = BAD;\n break;\n }\n//#endif\n //Tracev((stderr, \"inflate: table sizes ok\\n\"));\n state.have = 0;\n state.mode = LENLENS;\n /* falls through */\n case LENLENS:\n while (state.have < state.ncode) {\n //=== NEEDBITS(3);\n while (bits < 3) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.lens[order[state.have++]] = (hold & 0x07);//BITS(3);\n //--- DROPBITS(3) ---//\n hold >>>= 3;\n bits -= 3;\n //---//\n }\n while (state.have < 19) {\n state.lens[order[state.have++]] = 0;\n }\n // We have separate tables & no pointers. 2 commented lines below not needed.\n //state.next = state.codes;\n //state.lencode = state.next;\n // Switch to use dynamic table\n state.lencode = state.lendyn;\n state.lenbits = 7;\n\n opts = { bits: state.lenbits };\n ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);\n state.lenbits = opts.bits;\n\n if (ret) {\n strm.msg = 'invalid code lengths set';\n state.mode = BAD;\n break;\n }\n //Tracev((stderr, \"inflate: code lengths ok\\n\"));\n state.have = 0;\n state.mode = CODELENS;\n /* falls through */\n case CODELENS:\n while (state.have < state.nlen + state.ndist) {\n for (;;) {\n here = state.lencode[hold & ((1 << state.lenbits) - 1)];/*BITS(state.lenbits)*/\n here_bits = here >>> 24;\n here_op = (here >>> 16) & 0xff;\n here_val = here & 0xffff;\n\n if ((here_bits) <= bits) { break; }\n //--- PULLBYTE() ---//\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n //---//\n }\n if (here_val < 16) {\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n state.lens[state.have++] = here_val;\n }\n else {\n if (here_val === 16) {\n //=== NEEDBITS(here.bits + 2);\n n = here_bits + 2;\n while (bits < n) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n if (state.have === 0) {\n strm.msg = 'invalid bit length repeat';\n state.mode = BAD;\n break;\n }\n len = state.lens[state.have - 1];\n copy = 3 + (hold & 0x03);//BITS(2);\n //--- DROPBITS(2) ---//\n hold >>>= 2;\n bits -= 2;\n //---//\n }\n else if (here_val === 17) {\n //=== NEEDBITS(here.bits + 3);\n n = here_bits + 3;\n while (bits < n) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n len = 0;\n copy = 3 + (hold & 0x07);//BITS(3);\n //--- DROPBITS(3) ---//\n hold >>>= 3;\n bits -= 3;\n //---//\n }\n else {\n //=== NEEDBITS(here.bits + 7);\n n = here_bits + 7;\n while (bits < n) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n len = 0;\n copy = 11 + (hold & 0x7f);//BITS(7);\n //--- DROPBITS(7) ---//\n hold >>>= 7;\n bits -= 7;\n //---//\n }\n if (state.have + copy > state.nlen + state.ndist) {\n strm.msg = 'invalid bit length repeat';\n state.mode = BAD;\n break;\n }\n while (copy--) {\n state.lens[state.have++] = len;\n }\n }\n }\n\n /* handle error breaks in while */\n if (state.mode === BAD) { break; }\n\n /* check for end-of-block code (better have one) */\n if (state.lens[256] === 0) {\n strm.msg = 'invalid code -- missing end-of-block';\n state.mode = BAD;\n break;\n }\n\n /* build code tables -- note: do not change the lenbits or distbits\n values here (9 and 6) without reading the comments in inftrees.h\n concerning the ENOUGH constants, which depend on those values */\n state.lenbits = 9;\n\n opts = { bits: state.lenbits };\n ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);\n // We have separate tables & no pointers. 2 commented lines below not needed.\n // state.next_index = opts.table_index;\n state.lenbits = opts.bits;\n // state.lencode = state.next;\n\n if (ret) {\n strm.msg = 'invalid literal/lengths set';\n state.mode = BAD;\n break;\n }\n\n state.distbits = 6;\n //state.distcode.copy(state.codes);\n // Switch to use dynamic table\n state.distcode = state.distdyn;\n opts = { bits: state.distbits };\n ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);\n // We have separate tables & no pointers. 2 commented lines below not needed.\n // state.next_index = opts.table_index;\n state.distbits = opts.bits;\n // state.distcode = state.next;\n\n if (ret) {\n strm.msg = 'invalid distances set';\n state.mode = BAD;\n break;\n }\n //Tracev((stderr, 'inflate: codes ok\\n'));\n state.mode = LEN_;\n if (flush === Z_TREES) { break inf_leave; }\n /* falls through */\n case LEN_:\n state.mode = LEN;\n /* falls through */\n case LEN:\n if (have >= 6 && left >= 258) {\n //--- RESTORE() ---\n strm.next_out = put;\n strm.avail_out = left;\n strm.next_in = next;\n strm.avail_in = have;\n state.hold = hold;\n state.bits = bits;\n //---\n inflate_fast(strm, _out);\n //--- LOAD() ---\n put = strm.next_out;\n output = strm.output;\n left = strm.avail_out;\n next = strm.next_in;\n input = strm.input;\n have = strm.avail_in;\n hold = state.hold;\n bits = state.bits;\n //---\n\n if (state.mode === TYPE) {\n state.back = -1;\n }\n break;\n }\n state.back = 0;\n for (;;) {\n here = state.lencode[hold & ((1 << state.lenbits) - 1)]; /*BITS(state.lenbits)*/\n here_bits = here >>> 24;\n here_op = (here >>> 16) & 0xff;\n here_val = here & 0xffff;\n\n if (here_bits <= bits) { break; }\n //--- PULLBYTE() ---//\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n //---//\n }\n if (here_op && (here_op & 0xf0) === 0) {\n last_bits = here_bits;\n last_op = here_op;\n last_val = here_val;\n for (;;) {\n here = state.lencode[last_val +\n ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];\n here_bits = here >>> 24;\n here_op = (here >>> 16) & 0xff;\n here_val = here & 0xffff;\n\n if ((last_bits + here_bits) <= bits) { break; }\n //--- PULLBYTE() ---//\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n //---//\n }\n //--- DROPBITS(last.bits) ---//\n hold >>>= last_bits;\n bits -= last_bits;\n //---//\n state.back += last_bits;\n }\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n state.back += here_bits;\n state.length = here_val;\n if (here_op === 0) {\n //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?\n // \"inflate: literal '%c'\\n\" :\n // \"inflate: literal 0x%02x\\n\", here.val));\n state.mode = LIT;\n break;\n }\n if (here_op & 32) {\n //Tracevv((stderr, \"inflate: end of block\\n\"));\n state.back = -1;\n state.mode = TYPE;\n break;\n }\n if (here_op & 64) {\n strm.msg = 'invalid literal/length code';\n state.mode = BAD;\n break;\n }\n state.extra = here_op & 15;\n state.mode = LENEXT;\n /* falls through */\n case LENEXT:\n if (state.extra) {\n //=== NEEDBITS(state.extra);\n n = state.extra;\n while (bits < n) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.length += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;\n //--- DROPBITS(state.extra) ---//\n hold >>>= state.extra;\n bits -= state.extra;\n //---//\n state.back += state.extra;\n }\n //Tracevv((stderr, \"inflate: length %u\\n\", state.length));\n state.was = state.length;\n state.mode = DIST;\n /* falls through */\n case DIST:\n for (;;) {\n here = state.distcode[hold & ((1 << state.distbits) - 1)];/*BITS(state.distbits)*/\n here_bits = here >>> 24;\n here_op = (here >>> 16) & 0xff;\n here_val = here & 0xffff;\n\n if ((here_bits) <= bits) { break; }\n //--- PULLBYTE() ---//\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n //---//\n }\n if ((here_op & 0xf0) === 0) {\n last_bits = here_bits;\n last_op = here_op;\n last_val = here_val;\n for (;;) {\n here = state.distcode[last_val +\n ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];\n here_bits = here >>> 24;\n here_op = (here >>> 16) & 0xff;\n here_val = here & 0xffff;\n\n if ((last_bits + here_bits) <= bits) { break; }\n //--- PULLBYTE() ---//\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n //---//\n }\n //--- DROPBITS(last.bits) ---//\n hold >>>= last_bits;\n bits -= last_bits;\n //---//\n state.back += last_bits;\n }\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n state.back += here_bits;\n if (here_op & 64) {\n strm.msg = 'invalid distance code';\n state.mode = BAD;\n break;\n }\n state.offset = here_val;\n state.extra = (here_op) & 15;\n state.mode = DISTEXT;\n /* falls through */\n case DISTEXT:\n if (state.extra) {\n //=== NEEDBITS(state.extra);\n n = state.extra;\n while (bits < n) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.offset += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;\n //--- DROPBITS(state.extra) ---//\n hold >>>= state.extra;\n bits -= state.extra;\n //---//\n state.back += state.extra;\n }\n//#ifdef INFLATE_STRICT\n if (state.offset > state.dmax) {\n strm.msg = 'invalid distance too far back';\n state.mode = BAD;\n break;\n }\n//#endif\n //Tracevv((stderr, \"inflate: distance %u\\n\", state.offset));\n state.mode = MATCH;\n /* falls through */\n case MATCH:\n if (left === 0) { break inf_leave; }\n copy = _out - left;\n if (state.offset > copy) { /* copy from window */\n copy = state.offset - copy;\n if (copy > state.whave) {\n if (state.sane) {\n strm.msg = 'invalid distance too far back';\n state.mode = BAD;\n break;\n }\n// (!) This block is disabled in zlib defailts,\n// don't enable it for binary compatibility\n//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR\n// Trace((stderr, \"inflate.c too far\\n\"));\n// copy -= state.whave;\n// if (copy > state.length) { copy = state.length; }\n// if (copy > left) { copy = left; }\n// left -= copy;\n// state.length -= copy;\n// do {\n// output[put++] = 0;\n// } while (--copy);\n// if (state.length === 0) { state.mode = LEN; }\n// break;\n//#endif\n }\n if (copy > state.wnext) {\n copy -= state.wnext;\n from = state.wsize - copy;\n }\n else {\n from = state.wnext - copy;\n }\n if (copy > state.length) { copy = state.length; }\n from_source = state.window;\n }\n else { /* copy from output */\n from_source = output;\n from = put - state.offset;\n copy = state.length;\n }\n if (copy > left) { copy = left; }\n left -= copy;\n state.length -= copy;\n do {\n output[put++] = from_source[from++];\n } while (--copy);\n if (state.length === 0) { state.mode = LEN; }\n break;\n case LIT:\n if (left === 0) { break inf_leave; }\n output[put++] = state.length;\n left--;\n state.mode = LEN;\n break;\n case CHECK:\n if (state.wrap) {\n //=== NEEDBITS(32);\n while (bits < 32) {\n if (have === 0) { break inf_leave; }\n have--;\n // Use '|' insdead of '+' to make sure that result is signed\n hold |= input[next++] << bits;\n bits += 8;\n }\n //===//\n _out -= left;\n strm.total_out += _out;\n state.total += _out;\n if (_out) {\n strm.adler = state.check =\n /*UPDATE(state.check, put - _out, _out);*/\n (state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out));\n\n }\n _out = left;\n // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too\n if ((state.flags ? hold : zswap32(hold)) !== state.check) {\n strm.msg = 'incorrect data check';\n state.mode = BAD;\n break;\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n //Tracev((stderr, \"inflate: check matches trailer\\n\"));\n }\n state.mode = LENGTH;\n /* falls through */\n case LENGTH:\n if (state.wrap && state.flags) {\n //=== NEEDBITS(32);\n while (bits < 32) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if (hold !== (state.total & 0xffffffff)) {\n strm.msg = 'incorrect length check';\n state.mode = BAD;\n break;\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n //Tracev((stderr, \"inflate: length matches trailer\\n\"));\n }\n state.mode = DONE;\n /* falls through */\n case DONE:\n ret = Z_STREAM_END;\n break inf_leave;\n case BAD:\n ret = Z_DATA_ERROR;\n break inf_leave;\n case MEM:\n return Z_MEM_ERROR;\n case SYNC:\n /* falls through */\n default:\n return Z_STREAM_ERROR;\n }\n }\n\n // inf_leave <- here is real place for \"goto inf_leave\", emulated via \"break inf_leave\"\n\n /*\n Return from inflate(), updating the total counts and the check value.\n If there was no progress during the inflate() call, return a buffer\n error. Call updatewindow() to create and/or update the window state.\n Note: a memory error from inflate() is non-recoverable.\n */\n\n //--- RESTORE() ---\n strm.next_out = put;\n strm.avail_out = left;\n strm.next_in = next;\n strm.avail_in = have;\n state.hold = hold;\n state.bits = bits;\n //---\n\n if (state.wsize || (_out !== strm.avail_out && state.mode < BAD &&\n (state.mode < CHECK || flush !== Z_FINISH))) {\n if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) {\n state.mode = MEM;\n return Z_MEM_ERROR;\n }\n }\n _in -= strm.avail_in;\n _out -= strm.avail_out;\n strm.total_in += _in;\n strm.total_out += _out;\n state.total += _out;\n if (state.wrap && _out) {\n strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/\n (state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out));\n }\n strm.data_type = state.bits + (state.last ? 64 : 0) +\n (state.mode === TYPE ? 128 : 0) +\n (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);\n if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) {\n ret = Z_BUF_ERROR;\n }\n return ret;\n}\n\nfunction inflateEnd(strm) {\n\n if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) {\n return Z_STREAM_ERROR;\n }\n\n var state = strm.state;\n if (state.window) {\n state.window = null;\n }\n strm.state = null;\n return Z_OK;\n}\n\nfunction inflateGetHeader(strm, head) {\n var state;\n\n /* check state */\n if (!strm || !strm.state) { return Z_STREAM_ERROR; }\n state = strm.state;\n if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; }\n\n /* save header structure */\n state.head = head;\n head.done = false;\n return Z_OK;\n}\n\nfunction inflateSetDictionary(strm, dictionary) {\n var dictLength = dictionary.length;\n\n var state;\n var dictid;\n var ret;\n\n /* check state */\n if (!strm /* == Z_NULL */ || !strm.state /* == Z_NULL */) { return Z_STREAM_ERROR; }\n state = strm.state;\n\n if (state.wrap !== 0 && state.mode !== DICT) {\n return Z_STREAM_ERROR;\n }\n\n /* check for correct dictionary identifier */\n if (state.mode === DICT) {\n dictid = 1; /* adler32(0, null, 0)*/\n /* dictid = adler32(dictid, dictionary, dictLength); */\n dictid = adler32(dictid, dictionary, dictLength, 0);\n if (dictid !== state.check) {\n return Z_DATA_ERROR;\n }\n }\n /* copy dictionary to window using updatewindow(), which will amend the\n existing dictionary if appropriate */\n ret = updatewindow(strm, dictionary, dictLength, dictLength);\n if (ret) {\n state.mode = MEM;\n return Z_MEM_ERROR;\n }\n state.havedict = 1;\n // Tracev((stderr, \"inflate: dictionary set\\n\"));\n return Z_OK;\n}\n\nexports.inflateReset = inflateReset;\nexports.inflateReset2 = inflateReset2;\nexports.inflateResetKeep = inflateResetKeep;\nexports.inflateInit = inflateInit;\nexports.inflateInit2 = inflateInit2;\nexports.inflate = inflate;\nexports.inflateEnd = inflateEnd;\nexports.inflateGetHeader = inflateGetHeader;\nexports.inflateSetDictionary = inflateSetDictionary;\nexports.inflateInfo = 'pako inflate (from Nodeca project)';\n\n/* Not implemented\nexports.inflateCopy = inflateCopy;\nexports.inflateGetDictionary = inflateGetDictionary;\nexports.inflateMark = inflateMark;\nexports.inflatePrime = inflatePrime;\nexports.inflateSync = inflateSync;\nexports.inflateSyncPoint = inflateSyncPoint;\nexports.inflateUndermine = inflateUndermine;\n*/\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/pako/lib/zlib/inflate.js\n// module id = 20\n// module chunks = 0","'use strict';\n\n\nvar utils = require('../utils/common');\n\nvar MAXBITS = 15;\nvar ENOUGH_LENS = 852;\nvar ENOUGH_DISTS = 592;\n//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);\n\nvar CODES = 0;\nvar LENS = 1;\nvar DISTS = 2;\n\nvar lbase = [ /* Length codes 257..285 base */\n 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,\n 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0\n];\n\nvar lext = [ /* Length codes 257..285 extra */\n 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,\n 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78\n];\n\nvar dbase = [ /* Distance codes 0..29 base */\n 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,\n 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,\n 8193, 12289, 16385, 24577, 0, 0\n];\n\nvar dext = [ /* Distance codes 0..29 extra */\n 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,\n 23, 23, 24, 24, 25, 25, 26, 26, 27, 27,\n 28, 28, 29, 29, 64, 64\n];\n\nmodule.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts)\n{\n var bits = opts.bits;\n //here = opts.here; /* table entry for duplication */\n\n var len = 0; /* a code's length in bits */\n var sym = 0; /* index of code symbols */\n var min = 0, max = 0; /* minimum and maximum code lengths */\n var root = 0; /* number of index bits for root table */\n var curr = 0; /* number of index bits for current table */\n var drop = 0; /* code bits to drop for sub-table */\n var left = 0; /* number of prefix codes available */\n var used = 0; /* code entries in table used */\n var huff = 0; /* Huffman code */\n var incr; /* for incrementing code, index */\n var fill; /* index for replicating entries */\n var low; /* low bits for current root entry */\n var mask; /* mask for low root bits */\n var next; /* next available space in table */\n var base = null; /* base value table to use */\n var base_index = 0;\n// var shoextra; /* extra bits table to use */\n var end; /* use base and extra for symbol > end */\n var count = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* number of codes of each length */\n var offs = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* offsets in table for each length */\n var extra = null;\n var extra_index = 0;\n\n var here_bits, here_op, here_val;\n\n /*\n Process a set of code lengths to create a canonical Huffman code. The\n code lengths are lens[0..codes-1]. Each length corresponds to the\n symbols 0..codes-1. The Huffman code is generated by first sorting the\n symbols by length from short to long, and retaining the symbol order\n for codes with equal lengths. Then the code starts with all zero bits\n for the first code of the shortest length, and the codes are integer\n increments for the same length, and zeros are appended as the length\n increases. For the deflate format, these bits are stored backwards\n from their more natural integer increment ordering, and so when the\n decoding tables are built in the large loop below, the integer codes\n are incremented backwards.\n\n This routine assumes, but does not check, that all of the entries in\n lens[] are in the range 0..MAXBITS. The caller must assure this.\n 1..MAXBITS is interpreted as that code length. zero means that that\n symbol does not occur in this code.\n\n The codes are sorted by computing a count of codes for each length,\n creating from that a table of starting indices for each length in the\n sorted table, and then entering the symbols in order in the sorted\n table. The sorted table is work[], with that space being provided by\n the caller.\n\n The length counts are used for other purposes as well, i.e. finding\n the minimum and maximum length codes, determining if there are any\n codes at all, checking for a valid set of lengths, and looking ahead\n at length counts to determine sub-table sizes when building the\n decoding tables.\n */\n\n /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */\n for (len = 0; len <= MAXBITS; len++) {\n count[len] = 0;\n }\n for (sym = 0; sym < codes; sym++) {\n count[lens[lens_index + sym]]++;\n }\n\n /* bound code lengths, force root to be within code lengths */\n root = bits;\n for (max = MAXBITS; max >= 1; max--) {\n if (count[max] !== 0) { break; }\n }\n if (root > max) {\n root = max;\n }\n if (max === 0) { /* no symbols to code at all */\n //table.op[opts.table_index] = 64; //here.op = (var char)64; /* invalid code marker */\n //table.bits[opts.table_index] = 1; //here.bits = (var char)1;\n //table.val[opts.table_index++] = 0; //here.val = (var short)0;\n table[table_index++] = (1 << 24) | (64 << 16) | 0;\n\n\n //table.op[opts.table_index] = 64;\n //table.bits[opts.table_index] = 1;\n //table.val[opts.table_index++] = 0;\n table[table_index++] = (1 << 24) | (64 << 16) | 0;\n\n opts.bits = 1;\n return 0; /* no symbols, but wait for decoding to report error */\n }\n for (min = 1; min < max; min++) {\n if (count[min] !== 0) { break; }\n }\n if (root < min) {\n root = min;\n }\n\n /* check for an over-subscribed or incomplete set of lengths */\n left = 1;\n for (len = 1; len <= MAXBITS; len++) {\n left <<= 1;\n left -= count[len];\n if (left < 0) {\n return -1;\n } /* over-subscribed */\n }\n if (left > 0 && (type === CODES || max !== 1)) {\n return -1; /* incomplete set */\n }\n\n /* generate offsets into symbol table for each length for sorting */\n offs[1] = 0;\n for (len = 1; len < MAXBITS; len++) {\n offs[len + 1] = offs[len] + count[len];\n }\n\n /* sort symbols by length, by symbol order within each length */\n for (sym = 0; sym < codes; sym++) {\n if (lens[lens_index + sym] !== 0) {\n work[offs[lens[lens_index + sym]]++] = sym;\n }\n }\n\n /*\n Create and fill in decoding tables. In this loop, the table being\n filled is at next and has curr index bits. The code being used is huff\n with length len. That code is converted to an index by dropping drop\n bits off of the bottom. For codes where len is less than drop + curr,\n those top drop + curr - len bits are incremented through all values to\n fill the table with replicated entries.\n\n root is the number of index bits for the root table. When len exceeds\n root, sub-tables are created pointed to by the root entry with an index\n of the low root bits of huff. This is saved in low to check for when a\n new sub-table should be started. drop is zero when the root table is\n being filled, and drop is root when sub-tables are being filled.\n\n When a new sub-table is needed, it is necessary to look ahead in the\n code lengths to determine what size sub-table is needed. The length\n counts are used for this, and so count[] is decremented as codes are\n entered in the tables.\n\n used keeps track of how many table entries have been allocated from the\n provided *table space. It is checked for LENS and DIST tables against\n the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in\n the initial root table size constants. See the comments in inftrees.h\n for more information.\n\n sym increments through all symbols, and the loop terminates when\n all codes of length max, i.e. all codes, have been processed. This\n routine permits incomplete codes, so another loop after this one fills\n in the rest of the decoding tables with invalid code markers.\n */\n\n /* set up for code type */\n // poor man optimization - use if-else instead of switch,\n // to avoid deopts in old v8\n if (type === CODES) {\n base = extra = work; /* dummy value--not used */\n end = 19;\n\n } else if (type === LENS) {\n base = lbase;\n base_index -= 257;\n extra = lext;\n extra_index -= 257;\n end = 256;\n\n } else { /* DISTS */\n base = dbase;\n extra = dext;\n end = -1;\n }\n\n /* initialize opts for loop */\n huff = 0; /* starting code */\n sym = 0; /* starting code symbol */\n len = min; /* starting code length */\n next = table_index; /* current table to fill in */\n curr = root; /* current table index bits */\n drop = 0; /* current bits to drop from code for index */\n low = -1; /* trigger new sub-table when len > root */\n used = 1 << root; /* use root table entries */\n mask = used - 1; /* mask for comparing low */\n\n /* check available table space */\n if ((type === LENS && used > ENOUGH_LENS) ||\n (type === DISTS && used > ENOUGH_DISTS)) {\n return 1;\n }\n\n /* process all codes and make table entries */\n for (;;) {\n /* create table entry */\n here_bits = len - drop;\n if (work[sym] < end) {\n here_op = 0;\n here_val = work[sym];\n }\n else if (work[sym] > end) {\n here_op = extra[extra_index + work[sym]];\n here_val = base[base_index + work[sym]];\n }\n else {\n here_op = 32 + 64; /* end of block */\n here_val = 0;\n }\n\n /* replicate for those indices with low len bits equal to huff */\n incr = 1 << (len - drop);\n fill = 1 << curr;\n min = fill; /* save offset to next table */\n do {\n fill -= incr;\n table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val |0;\n } while (fill !== 0);\n\n /* backwards increment the len-bit code huff */\n incr = 1 << (len - 1);\n while (huff & incr) {\n incr >>= 1;\n }\n if (incr !== 0) {\n huff &= incr - 1;\n huff += incr;\n } else {\n huff = 0;\n }\n\n /* go to next symbol, update count, len */\n sym++;\n if (--count[len] === 0) {\n if (len === max) { break; }\n len = lens[lens_index + work[sym]];\n }\n\n /* create new sub-table if needed */\n if (len > root && (huff & mask) !== low) {\n /* if first time, transition to sub-tables */\n if (drop === 0) {\n drop = root;\n }\n\n /* increment past last table */\n next += min; /* here min is 1 << curr */\n\n /* determine length of next table */\n curr = len - drop;\n left = 1 << curr;\n while (curr + drop < max) {\n left -= count[curr + drop];\n if (left <= 0) { break; }\n curr++;\n left <<= 1;\n }\n\n /* check for enough space */\n used += 1 << curr;\n if ((type === LENS && used > ENOUGH_LENS) ||\n (type === DISTS && used > ENOUGH_DISTS)) {\n return 1;\n }\n\n /* point entry in root table to sub-table */\n low = huff & mask;\n /*table.op[low] = curr;\n table.bits[low] = root;\n table.val[low] = next - opts.table_index;*/\n table[low] = (root << 24) | (curr << 16) | (next - table_index) |0;\n }\n }\n\n /* fill in remaining table entry if code is incomplete (guaranteed to have\n at most one remaining entry, since if the code is incomplete, the\n maximum code length that was allowed to get this far is one bit) */\n if (huff !== 0) {\n //table.op[next + huff] = 64; /* invalid code marker */\n //table.bits[next + huff] = len - drop;\n //table.val[next + huff] = 0;\n table[next + huff] = ((len - drop) << 24) | (64 << 16) |0;\n }\n\n /* set return parameters */\n //opts.table_index += used;\n opts.bits = root;\n return 0;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/pako/lib/zlib/inftrees.js\n// module id = 21\n// module chunks = 0","'use strict';\n\nmodule.exports = {\n 2: 'need dictionary', /* Z_NEED_DICT 2 */\n 1: 'stream end', /* Z_STREAM_END 1 */\n 0: '', /* Z_OK 0 */\n '-1': 'file error', /* Z_ERRNO (-1) */\n '-2': 'stream error', /* Z_STREAM_ERROR (-2) */\n '-3': 'data error', /* Z_DATA_ERROR (-3) */\n '-4': 'insufficient memory', /* Z_MEM_ERROR (-4) */\n '-5': 'buffer error', /* Z_BUF_ERROR (-5) */\n '-6': 'incompatible version' /* Z_VERSION_ERROR (-6) */\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/pako/lib/zlib/messages.js\n// module id = 22\n// module chunks = 0","'use strict';\n\n\nfunction ZStream() {\n /* next input byte */\n this.input = null; // JS specific, because we have no pointers\n this.next_in = 0;\n /* number of bytes available at input */\n this.avail_in = 0;\n /* total number of input bytes read so far */\n this.total_in = 0;\n /* next output byte should be put there */\n this.output = null; // JS specific, because we have no pointers\n this.next_out = 0;\n /* remaining free space at output */\n this.avail_out = 0;\n /* total number of bytes output so far */\n this.total_out = 0;\n /* last error message, NULL if no error */\n this.msg = ''/*Z_NULL*/;\n /* not visible by applications */\n this.state = null;\n /* best guess about the data type: binary or text */\n this.data_type = 2/*Z_UNKNOWN*/;\n /* adler32 value of the uncompressed data */\n this.adler = 0;\n}\n\nmodule.exports = ZStream;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/pako/lib/zlib/zstream.js\n// module id = 23\n// module chunks = 0","(function () {\n var /*\n * Rusha, a JavaScript implementation of the Secure Hash Algorithm, SHA-1,\n * as defined in FIPS PUB 180-1, tuned for high performance with large inputs.\n * (http://github.com/srijs/rusha)\n *\n * Inspired by Paul Johnstons implementation (http://pajhome.org.uk/crypt/md5).\n *\n * Copyright (c) 2013 Sam Rijs (http://awesam.de).\n * Released under the terms of the MIT license as follows:\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the\n * Software is furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n util = {\n getDataType: function (data) {\n if (typeof data === 'string') {\n return 'string';\n }\n if (data instanceof Array) {\n return 'array';\n }\n if (typeof global !== 'undefined' && global.Buffer && global.Buffer.isBuffer(data)) {\n return 'buffer';\n }\n if (data instanceof ArrayBuffer) {\n return 'arraybuffer';\n }\n if (data.buffer instanceof ArrayBuffer) {\n return 'view';\n }\n if (data instanceof Blob) {\n return 'blob';\n }\n throw new Error('Unsupported data type.');\n }\n };\n function Rusha(chunkSize) {\n 'use strict';\n var // Private object structure.\n self$2 = { fill: 0 };\n var // Calculate the length of buffer that the sha1 routine uses\n // including the padding.\n padlen = function (len) {\n for (len += 9; len % 64 > 0; len += 1);\n return len;\n };\n var padZeroes = function (bin, len) {\n var h8 = new Uint8Array(bin.buffer);\n var om = len % 4, align = len - om;\n switch (om) {\n case 0:\n h8[align + 3] = 0;\n case 1:\n h8[align + 2] = 0;\n case 2:\n h8[align + 1] = 0;\n case 3:\n h8[align + 0] = 0;\n }\n for (var i$2 = (len >> 2) + 1; i$2 < bin.length; i$2++)\n bin[i$2] = 0;\n };\n var padData = function (bin, chunkLen, msgLen) {\n bin[chunkLen >> 2] |= 128 << 24 - (chunkLen % 4 << 3);\n // To support msgLen >= 2 GiB, use a float division when computing the\n // high 32-bits of the big-endian message length in bits.\n bin[((chunkLen >> 2) + 2 & ~15) + 14] = msgLen / (1 << 29) | 0;\n bin[((chunkLen >> 2) + 2 & ~15) + 15] = msgLen << 3;\n };\n var // Convert a binary string and write it to the heap.\n // A binary string is expected to only contain char codes < 256.\n convStr = function (H8, H32, start, len, off) {\n var str = this, i$2, om = off % 4, lm = (len + om) % 4, j = len - lm;\n switch (om) {\n case 0:\n H8[off] = str.charCodeAt(start + 3);\n case 1:\n H8[off + 1 - (om << 1) | 0] = str.charCodeAt(start + 2);\n case 2:\n H8[off + 2 - (om << 1) | 0] = str.charCodeAt(start + 1);\n case 3:\n H8[off + 3 - (om << 1) | 0] = str.charCodeAt(start);\n }\n if (len < lm + om) {\n return;\n }\n for (i$2 = 4 - om; i$2 < j; i$2 = i$2 + 4 | 0) {\n H32[off + i$2 >> 2] = str.charCodeAt(start + i$2) << 24 | str.charCodeAt(start + i$2 + 1) << 16 | str.charCodeAt(start + i$2 + 2) << 8 | str.charCodeAt(start + i$2 + 3);\n }\n switch (lm) {\n case 3:\n H8[off + j + 1 | 0] = str.charCodeAt(start + j + 2);\n case 2:\n H8[off + j + 2 | 0] = str.charCodeAt(start + j + 1);\n case 1:\n H8[off + j + 3 | 0] = str.charCodeAt(start + j);\n }\n };\n var // Convert a buffer or array and write it to the heap.\n // The buffer or array is expected to only contain elements < 256.\n convBuf = function (H8, H32, start, len, off) {\n var buf = this, i$2, om = off % 4, lm = (len + om) % 4, j = len - lm;\n switch (om) {\n case 0:\n H8[off] = buf[start + 3];\n case 1:\n H8[off + 1 - (om << 1) | 0] = buf[start + 2];\n case 2:\n H8[off + 2 - (om << 1) | 0] = buf[start + 1];\n case 3:\n H8[off + 3 - (om << 1) | 0] = buf[start];\n }\n if (len < lm + om) {\n return;\n }\n for (i$2 = 4 - om; i$2 < j; i$2 = i$2 + 4 | 0) {\n H32[off + i$2 >> 2 | 0] = buf[start + i$2] << 24 | buf[start + i$2 + 1] << 16 | buf[start + i$2 + 2] << 8 | buf[start + i$2 + 3];\n }\n switch (lm) {\n case 3:\n H8[off + j + 1 | 0] = buf[start + j + 2];\n case 2:\n H8[off + j + 2 | 0] = buf[start + j + 1];\n case 1:\n H8[off + j + 3 | 0] = buf[start + j];\n }\n };\n var convBlob = function (H8, H32, start, len, off) {\n var blob = this, i$2, om = off % 4, lm = (len + om) % 4, j = len - lm;\n var buf = new Uint8Array(reader.readAsArrayBuffer(blob.slice(start, start + len)));\n switch (om) {\n case 0:\n H8[off] = buf[3];\n case 1:\n H8[off + 1 - (om << 1) | 0] = buf[2];\n case 2:\n H8[off + 2 - (om << 1) | 0] = buf[1];\n case 3:\n H8[off + 3 - (om << 1) | 0] = buf[0];\n }\n if (len < lm + om) {\n return;\n }\n for (i$2 = 4 - om; i$2 < j; i$2 = i$2 + 4 | 0) {\n H32[off + i$2 >> 2 | 0] = buf[i$2] << 24 | buf[i$2 + 1] << 16 | buf[i$2 + 2] << 8 | buf[i$2 + 3];\n }\n switch (lm) {\n case 3:\n H8[off + j + 1 | 0] = buf[j + 2];\n case 2:\n H8[off + j + 2 | 0] = buf[j + 1];\n case 1:\n H8[off + j + 3 | 0] = buf[j];\n }\n };\n var convFn = function (data) {\n switch (util.getDataType(data)) {\n case 'string':\n return convStr.bind(data);\n case 'array':\n return convBuf.bind(data);\n case 'buffer':\n return convBuf.bind(data);\n case 'arraybuffer':\n return convBuf.bind(new Uint8Array(data));\n case 'view':\n return convBuf.bind(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));\n case 'blob':\n return convBlob.bind(data);\n }\n };\n var slice = function (data, offset) {\n switch (util.getDataType(data)) {\n case 'string':\n return data.slice(offset);\n case 'array':\n return data.slice(offset);\n case 'buffer':\n return data.slice(offset);\n case 'arraybuffer':\n return data.slice(offset);\n case 'view':\n return data.buffer.slice(offset);\n }\n };\n var // Precompute 00 - ff strings\n precomputedHex = new Array(256);\n for (var i = 0; i < 256; i++) {\n precomputedHex[i] = (i < 16 ? '0' : '') + i.toString(16);\n }\n var // Convert an ArrayBuffer into its hexadecimal string representation.\n hex = function (arrayBuffer) {\n var binarray = new Uint8Array(arrayBuffer);\n var res = new Array(arrayBuffer.byteLength);\n for (var i$2 = 0; i$2 < res.length; i$2++) {\n res[i$2] = precomputedHex[binarray[i$2]];\n }\n return res.join('');\n };\n var ceilHeapSize = function (v) {\n // The asm.js spec says:\n // The heap object's byteLength must be either\n // 2^n for n in [12, 24) or 2^24 * n for n ≥ 1.\n // Also, byteLengths smaller than 2^16 are deprecated.\n var p;\n if (// If v is smaller than 2^16, the smallest possible solution\n // is 2^16.\n v <= 65536)\n return 65536;\n if (// If v < 2^24, we round up to 2^n,\n // otherwise we round up to 2^24 * n.\n v < 16777216) {\n for (p = 1; p < v; p = p << 1);\n } else {\n for (p = 16777216; p < v; p += 16777216);\n }\n return p;\n };\n var // Initialize the internal data structures to a new capacity.\n init = function (size) {\n if (size % 64 > 0) {\n throw new Error('Chunk size must be a multiple of 128 bit');\n }\n self$2.offset = 0;\n self$2.maxChunkLen = size;\n self$2.padMaxChunkLen = padlen(size);\n // The size of the heap is the sum of:\n // 1. The padded input message size\n // 2. The extended space the algorithm needs (320 byte)\n // 3. The 160 bit state the algoritm uses\n self$2.heap = new ArrayBuffer(ceilHeapSize(self$2.padMaxChunkLen + 320 + 20));\n self$2.h32 = new Int32Array(self$2.heap);\n self$2.h8 = new Int8Array(self$2.heap);\n self$2.core = new Rusha._core({\n Int32Array: Int32Array,\n DataView: DataView\n }, {}, self$2.heap);\n self$2.buffer = null;\n };\n // Iinitializethe datastructures according\n // to a chunk siyze.\n init(chunkSize || 64 * 1024);\n var initState = function (heap, padMsgLen) {\n self$2.offset = 0;\n var io = new Int32Array(heap, padMsgLen + 320, 5);\n io[0] = 1732584193;\n io[1] = -271733879;\n io[2] = -1732584194;\n io[3] = 271733878;\n io[4] = -1009589776;\n };\n var padChunk = function (chunkLen, msgLen) {\n var padChunkLen = padlen(chunkLen);\n var view = new Int32Array(self$2.heap, 0, padChunkLen >> 2);\n padZeroes(view, chunkLen);\n padData(view, chunkLen, msgLen);\n return padChunkLen;\n };\n var // Write data to the heap.\n write = function (data, chunkOffset, chunkLen, off) {\n convFn(data)(self$2.h8, self$2.h32, chunkOffset, chunkLen, off || 0);\n };\n var // Initialize and call the RushaCore,\n // assuming an input buffer of length len * 4.\n coreCall = function (data, chunkOffset, chunkLen, msgLen, finalize) {\n var padChunkLen = chunkLen;\n write(data, chunkOffset, chunkLen);\n if (finalize) {\n padChunkLen = padChunk(chunkLen, msgLen);\n }\n self$2.core.hash(padChunkLen, self$2.padMaxChunkLen);\n };\n var getRawDigest = function (heap, padMaxChunkLen) {\n var io = new Int32Array(heap, padMaxChunkLen + 320, 5);\n var out = new Int32Array(5);\n var arr = new DataView(out.buffer);\n arr.setInt32(0, io[0], false);\n arr.setInt32(4, io[1], false);\n arr.setInt32(8, io[2], false);\n arr.setInt32(12, io[3], false);\n arr.setInt32(16, io[4], false);\n return out;\n };\n var // Calculate the hash digest as an array of 5 32bit integers.\n rawDigest = this.rawDigest = function (str) {\n var msgLen = str.byteLength || str.length || str.size || 0;\n initState(self$2.heap, self$2.padMaxChunkLen);\n var chunkOffset = 0, chunkLen = self$2.maxChunkLen, last;\n for (chunkOffset = 0; msgLen > chunkOffset + chunkLen; chunkOffset += chunkLen) {\n coreCall(str, chunkOffset, chunkLen, msgLen, false);\n }\n coreCall(str, chunkOffset, msgLen - chunkOffset, msgLen, true);\n return getRawDigest(self$2.heap, self$2.padMaxChunkLen);\n };\n // The digest and digestFrom* interface returns the hash digest\n // as a hex string.\n this.digest = this.digestFromString = this.digestFromBuffer = this.digestFromArrayBuffer = function (str) {\n return hex(rawDigest(str).buffer);\n };\n this.resetState = function () {\n initState(self$2.heap, self$2.padMaxChunkLen);\n return this;\n };\n this.append = function (chunk) {\n var chunkOffset = 0;\n var chunkLen = chunk.byteLength || chunk.length || chunk.size || 0;\n var turnOffset = self$2.offset % self$2.maxChunkLen;\n var inputLen;\n self$2.offset += chunkLen;\n while (chunkOffset < chunkLen) {\n inputLen = Math.min(chunkLen - chunkOffset, self$2.maxChunkLen - turnOffset);\n write(chunk, chunkOffset, inputLen, turnOffset);\n turnOffset += inputLen;\n chunkOffset += inputLen;\n if (turnOffset === self$2.maxChunkLen) {\n self$2.core.hash(self$2.maxChunkLen, self$2.padMaxChunkLen);\n turnOffset = 0;\n }\n }\n return this;\n };\n this.getState = function () {\n var turnOffset = self$2.offset % self$2.maxChunkLen;\n var heap;\n if (!turnOffset) {\n var io = new Int32Array(self$2.heap, self$2.padMaxChunkLen + 320, 5);\n heap = io.buffer.slice(io.byteOffset, io.byteOffset + io.byteLength);\n } else {\n heap = self$2.heap.slice(0);\n }\n return {\n offset: self$2.offset,\n heap: heap\n };\n };\n this.setState = function (state) {\n self$2.offset = state.offset;\n if (state.heap.byteLength === 20) {\n var io = new Int32Array(self$2.heap, self$2.padMaxChunkLen + 320, 5);\n io.set(new Int32Array(state.heap));\n } else {\n self$2.h32.set(new Int32Array(state.heap));\n }\n return this;\n };\n var rawEnd = this.rawEnd = function () {\n var msgLen = self$2.offset;\n var chunkLen = msgLen % self$2.maxChunkLen;\n var padChunkLen = padChunk(chunkLen, msgLen);\n self$2.core.hash(padChunkLen, self$2.padMaxChunkLen);\n var result = getRawDigest(self$2.heap, self$2.padMaxChunkLen);\n initState(self$2.heap, self$2.padMaxChunkLen);\n return result;\n };\n this.end = function () {\n return hex(rawEnd().buffer);\n };\n }\n ;\n // The low-level RushCore module provides the heart of Rusha,\n // a high-speed sha1 implementation working on an Int32Array heap.\n // At first glance, the implementation seems complicated, however\n // with the SHA1 spec at hand, it is obvious this almost a textbook\n // implementation that has a few functions hand-inlined and a few loops\n // hand-unrolled.\n Rusha._core = function RushaCore(stdlib, foreign, heap) {\n 'use asm';\n var H = new stdlib.Int32Array(heap);\n function hash(k, x) {\n // k in bytes\n k = k | 0;\n x = x | 0;\n var i = 0, j = 0, y0 = 0, z0 = 0, y1 = 0, z1 = 0, y2 = 0, z2 = 0, y3 = 0, z3 = 0, y4 = 0, z4 = 0, t0 = 0, t1 = 0;\n y0 = H[x + 320 >> 2] | 0;\n y1 = H[x + 324 >> 2] | 0;\n y2 = H[x + 328 >> 2] | 0;\n y3 = H[x + 332 >> 2] | 0;\n y4 = H[x + 336 >> 2] | 0;\n for (i = 0; (i | 0) < (k | 0); i = i + 64 | 0) {\n z0 = y0;\n z1 = y1;\n z2 = y2;\n z3 = y3;\n z4 = y4;\n for (j = 0; (j | 0) < 64; j = j + 4 | 0) {\n t1 = H[i + j >> 2] | 0;\n t0 = ((y0 << 5 | y0 >>> 27) + (y1 & y2 | ~y1 & y3) | 0) + ((t1 + y4 | 0) + 1518500249 | 0) | 0;\n y4 = y3;\n y3 = y2;\n y2 = y1 << 30 | y1 >>> 2;\n y1 = y0;\n y0 = t0;\n H[k + j >> 2] = t1;\n }\n for (j = k + 64 | 0; (j | 0) < (k + 80 | 0); j = j + 4 | 0) {\n t1 = (H[j - 12 >> 2] ^ H[j - 32 >> 2] ^ H[j - 56 >> 2] ^ H[j - 64 >> 2]) << 1 | (H[j - 12 >> 2] ^ H[j - 32 >> 2] ^ H[j - 56 >> 2] ^ H[j - 64 >> 2]) >>> 31;\n t0 = ((y0 << 5 | y0 >>> 27) + (y1 & y2 | ~y1 & y3) | 0) + ((t1 + y4 | 0) + 1518500249 | 0) | 0;\n y4 = y3;\n y3 = y2;\n y2 = y1 << 30 | y1 >>> 2;\n y1 = y0;\n y0 = t0;\n H[j >> 2] = t1;\n }\n for (j = k + 80 | 0; (j | 0) < (k + 160 | 0); j = j + 4 | 0) {\n t1 = (H[j - 12 >> 2] ^ H[j - 32 >> 2] ^ H[j - 56 >> 2] ^ H[j - 64 >> 2]) << 1 | (H[j - 12 >> 2] ^ H[j - 32 >> 2] ^ H[j - 56 >> 2] ^ H[j - 64 >> 2]) >>> 31;\n t0 = ((y0 << 5 | y0 >>> 27) + (y1 ^ y2 ^ y3) | 0) + ((t1 + y4 | 0) + 1859775393 | 0) | 0;\n y4 = y3;\n y3 = y2;\n y2 = y1 << 30 | y1 >>> 2;\n y1 = y0;\n y0 = t0;\n H[j >> 2] = t1;\n }\n for (j = k + 160 | 0; (j | 0) < (k + 240 | 0); j = j + 4 | 0) {\n t1 = (H[j - 12 >> 2] ^ H[j - 32 >> 2] ^ H[j - 56 >> 2] ^ H[j - 64 >> 2]) << 1 | (H[j - 12 >> 2] ^ H[j - 32 >> 2] ^ H[j - 56 >> 2] ^ H[j - 64 >> 2]) >>> 31;\n t0 = ((y0 << 5 | y0 >>> 27) + (y1 & y2 | y1 & y3 | y2 & y3) | 0) + ((t1 + y4 | 0) - 1894007588 | 0) | 0;\n y4 = y3;\n y3 = y2;\n y2 = y1 << 30 | y1 >>> 2;\n y1 = y0;\n y0 = t0;\n H[j >> 2] = t1;\n }\n for (j = k + 240 | 0; (j | 0) < (k + 320 | 0); j = j + 4 | 0) {\n t1 = (H[j - 12 >> 2] ^ H[j - 32 >> 2] ^ H[j - 56 >> 2] ^ H[j - 64 >> 2]) << 1 | (H[j - 12 >> 2] ^ H[j - 32 >> 2] ^ H[j - 56 >> 2] ^ H[j - 64 >> 2]) >>> 31;\n t0 = ((y0 << 5 | y0 >>> 27) + (y1 ^ y2 ^ y3) | 0) + ((t1 + y4 | 0) - 899497514 | 0) | 0;\n y4 = y3;\n y3 = y2;\n y2 = y1 << 30 | y1 >>> 2;\n y1 = y0;\n y0 = t0;\n H[j >> 2] = t1;\n }\n y0 = y0 + z0 | 0;\n y1 = y1 + z1 | 0;\n y2 = y2 + z2 | 0;\n y3 = y3 + z3 | 0;\n y4 = y4 + z4 | 0;\n }\n H[x + 320 >> 2] = y0;\n H[x + 324 >> 2] = y1;\n H[x + 328 >> 2] = y2;\n H[x + 332 >> 2] = y3;\n H[x + 336 >> 2] = y4;\n }\n return { hash: hash };\n };\n if (// If we'e running in Node.JS, export a module.\n typeof module !== 'undefined') {\n module.exports = Rusha;\n } else if (// If we're running in a DOM context, export\n // the Rusha object to toplevel.\n typeof window !== 'undefined') {\n window.Rusha = Rusha;\n }\n if (// If we're running in a webworker, accept\n // messages containing a jobid and a buffer\n // or blob object, and return the hash result.\n typeof FileReaderSync !== 'undefined') {\n var reader = new FileReaderSync(), hasher = new Rusha(4 * 1024 * 1024);\n self.onmessage = function onMessage(event) {\n var hash, data = event.data.data;\n try {\n hash = hasher.digest(data);\n self.postMessage({\n id: event.data.id,\n hash: hash\n });\n } catch (e) {\n self.postMessage({\n id: event.data.id,\n error: e.name\n });\n }\n };\n }\n}());\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/rusha/rusha.js\n// module id = 24\n// module chunks = 0","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/webpack/buildin/global.js\n// module id = 25\n// module chunks = 0","import { pqPrimeFactorization, bytesModPow, sha1HashSync,\r\n aesEncryptSync, aesDecryptSync } from './bin'\r\n\r\nconsole.info('Crypto worker registered')\r\n\r\nconst runTask = data => {\r\n switch (data.task) {\r\n case 'factorize' : return pqPrimeFactorization(data.bytes)\r\n case 'mod-pow' : return bytesModPow(data.x, data.y, data.m)\r\n case 'sha1-hash' : return sha1HashSync(data.bytes)\r\n case 'aes-encrypt': return aesEncryptSync(data.bytes, data.keyBytes, data.ivBytes)\r\n case 'aes-decrypt': return aesDecryptSync(data.encryptedBytes,\r\n data.keyBytes, data.ivBytes)\r\n default:\r\n throw new Error(`Unknown task: ${data.task}`)\r\n }\r\n}\r\n\r\nonmessage = function(e) {\r\n if (e.data === '') {\r\n console.info('empty crypto task')\r\n } else if (typeof e.data === 'string') {\r\n console.info('crypto task string message', e.data)\r\n } else {\r\n const taskID = e.data.taskID\r\n const result = runTask(e.data)\r\n postMessage({ taskID, result })\r\n }\r\n}\r\n\r\npostMessage('ready')\n\n\n// WEBPACK FOOTER //\n// ./worker.js"],"sourceRoot":""} |