|
|
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.EthEnsNamehash = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
|
'use strict'
|
|
|
|
|
|
exports.byteLength = byteLength
|
|
|
exports.toByteArray = toByteArray
|
|
|
exports.fromByteArray = fromByteArray
|
|
|
|
|
|
var lookup = []
|
|
|
var revLookup = []
|
|
|
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
|
|
|
|
|
|
var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
|
|
|
for (var i = 0, len = code.length; i < len; ++i) {
|
|
|
lookup[i] = code[i]
|
|
|
revLookup[code.charCodeAt(i)] = i
|
|
|
}
|
|
|
|
|
|
revLookup['-'.charCodeAt(0)] = 62
|
|
|
revLookup['_'.charCodeAt(0)] = 63
|
|
|
|
|
|
function placeHoldersCount (b64) {
|
|
|
var len = b64.length
|
|
|
if (len % 4 > 0) {
|
|
|
throw new Error('Invalid string. Length must be a multiple of 4')
|
|
|
}
|
|
|
|
|
|
// the number of equal signs (place holders)
|
|
|
// if there are two placeholders, than the two characters before it
|
|
|
// represent one byte
|
|
|
// if there is only one, then the three characters before it represent 2 bytes
|
|
|
// this is just a cheap hack to not do indexOf twice
|
|
|
return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0
|
|
|
}
|
|
|
|
|
|
function byteLength (b64) {
|
|
|
// base64 is 4/3 + up to two characters of the original data
|
|
|
return (b64.length * 3 / 4) - placeHoldersCount(b64)
|
|
|
}
|
|
|
|
|
|
function toByteArray (b64) {
|
|
|
var i, l, tmp, placeHolders, arr
|
|
|
var len = b64.length
|
|
|
placeHolders = placeHoldersCount(b64)
|
|
|
|
|
|
arr = new Arr((len * 3 / 4) - placeHolders)
|
|
|
|
|
|
// if there are placeholders, only get up to the last complete 4 chars
|
|
|
l = placeHolders > 0 ? len - 4 : len
|
|
|
|
|
|
var L = 0
|
|
|
|
|
|
for (i = 0; i < l; i += 4) {
|
|
|
tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]
|
|
|
arr[L++] = (tmp >> 16) & 0xFF
|
|
|
arr[L++] = (tmp >> 8) & 0xFF
|
|
|
arr[L++] = tmp & 0xFF
|
|
|
}
|
|
|
|
|
|
if (placeHolders === 2) {
|
|
|
tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)
|
|
|
arr[L++] = tmp & 0xFF
|
|
|
} else if (placeHolders === 1) {
|
|
|
tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)
|
|
|
arr[L++] = (tmp >> 8) & 0xFF
|
|
|
arr[L++] = tmp & 0xFF
|
|
|
}
|
|
|
|
|
|
return arr
|
|
|
}
|
|
|
|
|
|
function tripletToBase64 (num) {
|
|
|
return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
|
|
|
}
|
|
|
|
|
|
function encodeChunk (uint8, start, end) {
|
|
|
var tmp
|
|
|
var output = []
|
|
|
for (var i = start; i < end; i += 3) {
|
|
|
tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
|
|
|
output.push(tripletToBase64(tmp))
|
|
|
}
|
|
|
return output.join('')
|
|
|
}
|
|
|
|
|
|
function fromByteArray (uint8) {
|
|
|
var tmp
|
|
|
var len = uint8.length
|
|
|
var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
|
|
|
var output = ''
|
|
|
var parts = []
|
|
|
var maxChunkLength = 16383 // must be multiple of 3
|
|
|
|
|
|
// go through the array every three bytes, we'll deal with trailing stuff later
|
|
|
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
|
|
|
parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
|
|
|
}
|
|
|
|
|
|
// pad the end with zeros, but make sure to not forget the extra bytes
|
|
|
if (extraBytes === 1) {
|
|
|
tmp = uint8[len - 1]
|
|
|
output += lookup[tmp >> 2]
|
|
|
output += lookup[(tmp << 4) & 0x3F]
|
|
|
output += '=='
|
|
|
} else if (extraBytes === 2) {
|
|
|
tmp = (uint8[len - 2] << 8) + (uint8[len - 1])
|
|
|
output += lookup[tmp >> 10]
|
|
|
output += lookup[(tmp >> 4) & 0x3F]
|
|
|
output += lookup[(tmp << 2) & 0x3F]
|
|
|
output += '='
|
|
|
}
|
|
|
|
|
|
parts.push(output)
|
|
|
|
|
|
return parts.join('')
|
|
|
}
|
|
|
|
|
|
},{}],2:[function(require,module,exports){
|
|
|
/*!
|
|
|
* The buffer module from node.js, for the browser.
|
|
|
*
|
|
|
* @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
|
|
|
* @license MIT
|
|
|
*/
|
|
|
/* eslint-disable no-proto */
|
|
|
|
|
|
'use strict'
|
|
|
|
|
|
var base64 = require('base64-js')
|
|
|
var ieee754 = require('ieee754')
|
|
|
|
|
|
exports.Buffer = Buffer
|
|
|
exports.SlowBuffer = SlowBuffer
|
|
|
exports.INSPECT_MAX_BYTES = 50
|
|
|
|
|
|
var K_MAX_LENGTH = 0x7fffffff
|
|
|
exports.kMaxLength = K_MAX_LENGTH
|
|
|
|
|
|
/**
|
|
|
* If `Buffer.TYPED_ARRAY_SUPPORT`:
|
|
|
* === true Use Uint8Array implementation (fastest)
|
|
|
* === false Print warning and recommend using `buffer` v4.x which has an Object
|
|
|
* implementation (most compatible, even IE6)
|
|
|
*
|
|
|
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
|
|
|
* Opera 11.6+, iOS 4.2+.
|
|
|
*
|
|
|
* We report that the browser does not support typed arrays if the are not subclassable
|
|
|
* using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
|
|
|
* (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
|
|
|
* for __proto__ and has a buggy typed array implementation.
|
|
|
*/
|
|
|
Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
|
|
|
|
|
|
if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
|
|
|
typeof console.error === 'function') {
|
|
|
console.error(
|
|
|
'This browser lacks typed array (Uint8Array) support which is required by ' +
|
|
|
'`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
|
|
|
)
|
|
|
}
|
|
|
|
|
|
function typedArraySupport () {
|
|
|
// Can typed array instances can be augmented?
|
|
|
try {
|
|
|
var arr = new Uint8Array(1)
|
|
|
arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
|
|
|
return arr.foo() === 42
|
|
|
} catch (e) {
|
|
|
return false
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function createBuffer (length) {
|
|
|
if (length > K_MAX_LENGTH) {
|
|
|
throw new RangeError('Invalid typed array length')
|
|
|
}
|
|
|
// Return an augmented `Uint8Array` instance
|
|
|
var buf = new Uint8Array(length)
|
|
|
buf.__proto__ = Buffer.prototype
|
|
|
return buf
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* The Buffer constructor returns instances of `Uint8Array` that have their
|
|
|
* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
|
|
|
* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
|
|
|
* and the `Uint8Array` methods. Square bracket notation works as expected -- it
|
|
|
* returns a single octet.
|
|
|
*
|
|
|
* The `Uint8Array` prototype remains unmodified.
|
|
|
*/
|
|
|
|
|
|
function Buffer (arg, encodingOrOffset, length) {
|
|
|
// Common case.
|
|
|
if (typeof arg === 'number') {
|
|
|
if (typeof encodingOrOffset === 'string') {
|
|
|
throw new Error(
|
|
|
'If encoding is specified then the first argument must be a string'
|
|
|
)
|
|
|
}
|
|
|
return allocUnsafe(arg)
|
|
|
}
|
|
|
return from(arg, encodingOrOffset, length)
|
|
|
}
|
|
|
|
|
|
// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
|
|
|
if (typeof Symbol !== 'undefined' && Symbol.species &&
|
|
|
Buffer[Symbol.species] === Buffer) {
|
|
|
Object.defineProperty(Buffer, Symbol.species, {
|
|
|
value: null,
|
|
|
configurable: true,
|
|
|
enumerable: false,
|
|
|
writable: false
|
|
|
})
|
|
|
}
|
|
|
|
|
|
Buffer.poolSize = 8192 // not used by this implementation
|
|
|
|
|
|
function from (value, encodingOrOffset, length) {
|
|
|
if (typeof value === 'number') {
|
|
|
throw new TypeError('"value" argument must not be a number')
|
|
|
}
|
|
|
|
|
|
if (isArrayBuffer(value)) {
|
|
|
return fromArrayBuffer(value, encodingOrOffset, length)
|
|
|
}
|
|
|
|
|
|
if (typeof value === 'string') {
|
|
|
return fromString(value, encodingOrOffset)
|
|
|
}
|
|
|
|
|
|
return fromObject(value)
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
|
|
|
* if value is a number.
|
|
|
* Buffer.from(str[, encoding])
|
|
|
* Buffer.from(array)
|
|
|
* Buffer.from(buffer)
|
|
|
* Buffer.from(arrayBuffer[, byteOffset[, length]])
|
|
|
**/
|
|
|
Buffer.from = function (value, encodingOrOffset, length) {
|
|
|
return from(value, encodingOrOffset, length)
|
|
|
}
|
|
|
|
|
|
// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
|
|
|
// https://github.com/feross/buffer/pull/148
|
|
|
Buffer.prototype.__proto__ = Uint8Array.prototype
|
|
|
Buffer.__proto__ = Uint8Array
|
|
|
|
|
|
function assertSize (size) {
|
|
|
if (typeof size !== 'number') {
|
|
|
throw new TypeError('"size" argument must be a number')
|
|
|
} else if (size < 0) {
|
|
|
throw new RangeError('"size" argument must not be negative')
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function alloc (size, fill, encoding) {
|
|
|
assertSize(size)
|
|
|
if (size <= 0) {
|
|
|
return createBuffer(size)
|
|
|
}
|
|
|
if (fill !== undefined) {
|
|
|
// Only pay attention to encoding if it's a string. This
|
|
|
// prevents accidentally sending in a number that would
|
|
|
// be interpretted as a start offset.
|
|
|
return typeof encoding === 'string'
|
|
|
? createBuffer(size).fill(fill, encoding)
|
|
|
: createBuffer(size).fill(fill)
|
|
|
}
|
|
|
return createBuffer(size)
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Creates a new filled Buffer instance.
|
|
|
* alloc(size[, fill[, encoding]])
|
|
|
**/
|
|
|
Buffer.alloc = function (size, fill, encoding) {
|
|
|
return alloc(size, fill, encoding)
|
|
|
}
|
|
|
|
|
|
function allocUnsafe (size) {
|
|
|
assertSize(size)
|
|
|
return createBuffer(size < 0 ? 0 : checked(size) | 0)
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
|
|
|
* */
|
|
|
Buffer.allocUnsafe = function (size) {
|
|
|
return allocUnsafe(size)
|
|
|
}
|
|
|
/**
|
|
|
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
|
|
|
*/
|
|
|
Buffer.allocUnsafeSlow = function (size) {
|
|
|
return allocUnsafe(size)
|
|
|
}
|
|
|
|
|
|
function fromString (string, encoding) {
|
|
|
if (typeof encoding !== 'string' || encoding === '') {
|
|
|
encoding = 'utf8'
|
|
|
}
|
|
|
|
|
|
if (!Buffer.isEncoding(encoding)) {
|
|
|
throw new TypeError('"encoding" must be a valid string encoding')
|
|
|
}
|
|
|
|
|
|
var length = byteLength(string, encoding) | 0
|
|
|
var buf = createBuffer(length)
|
|
|
|
|
|
var actual = buf.write(string, encoding)
|
|
|
|
|
|
if (actual !== length) {
|
|
|
// Writing a hex string, for example, that contains invalid characters will
|
|
|
// cause everything after the first invalid character to be ignored. (e.g.
|
|
|
// 'abxxcd' will be treated as 'ab')
|
|
|
buf = buf.slice(0, actual)
|
|
|
}
|
|
|
|
|
|
return buf
|
|
|
}
|
|
|
|
|
|
function fromArrayLike (array) {
|
|
|
var length = array.length < 0 ? 0 : checked(array.length) | 0
|
|
|
var buf = createBuffer(length)
|
|
|
for (var i = 0; i < length; i += 1) {
|
|
|
buf[i] = array[i] & 255
|
|
|
}
|
|
|
return buf
|
|
|
}
|
|
|
|
|
|
function fromArrayBuffer (array, byteOffset, length) {
|
|
|
if (byteOffset < 0 || array.byteLength < byteOffset) {
|
|
|
throw new RangeError('\'offset\' is out of bounds')
|
|
|
}
|
|
|
|
|
|
if (array.byteLength < byteOffset + (length || 0)) {
|
|
|
throw new RangeError('\'length\' is out of bounds')
|
|
|
}
|
|
|
|
|
|
var buf
|
|
|
if (byteOffset === undefined && length === undefined) {
|
|
|
buf = new Uint8Array(array)
|
|
|
} else if (length === undefined) {
|
|
|
buf = new Uint8Array(array, byteOffset)
|
|
|
} else {
|
|
|
buf = new Uint8Array(array, byteOffset, length)
|
|
|
}
|
|
|
|
|
|
// Return an augmented `Uint8Array` instance
|
|
|
buf.__proto__ = Buffer.prototype
|
|
|
return buf
|
|
|
}
|
|
|
|
|
|
function fromObject (obj) {
|
|
|
if (Buffer.isBuffer(obj)) {
|
|
|
var len = checked(obj.length) | 0
|
|
|
var buf = createBuffer(len)
|
|
|
|
|
|
if (buf.length === 0) {
|
|
|
return buf
|
|
|
}
|
|
|
|
|
|
obj.copy(buf, 0, 0, len)
|
|
|
return buf
|
|
|
}
|
|
|
|
|
|
if (obj) {
|
|
|
if (isArrayBufferView(obj) || 'length' in obj) {
|
|
|
if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
|
|
|
return createBuffer(0)
|
|
|
}
|
|
|
return fromArrayLike(obj)
|
|
|
}
|
|
|
|
|
|
if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
|
|
|
return fromArrayLike(obj.data)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
|
|
|
}
|
|
|
|
|
|
function checked (length) {
|
|
|
// Note: cannot use `length < K_MAX_LENGTH` here because that fails when
|
|
|
// length is NaN (which is otherwise coerced to zero.)
|
|
|
if (length >= K_MAX_LENGTH) {
|
|
|
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
|
|
|
'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
|
|
|
}
|
|
|
return length | 0
|
|
|
}
|
|
|
|
|
|
function SlowBuffer (length) {
|
|
|
if (+length != length) { // eslint-disable-line eqeqeq
|
|
|
length = 0
|
|
|
}
|
|
|
return Buffer.alloc(+length)
|
|
|
}
|
|
|
|
|
|
Buffer.isBuffer = function isBuffer (b) {
|
|
|
return b != null && b._isBuffer === true
|
|
|
}
|
|
|
|
|
|
Buffer.compare = function compare (a, b) {
|
|
|
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
|
|
|
throw new TypeError('Arguments must be Buffers')
|
|
|
}
|
|
|
|
|
|
if (a === b) return 0
|
|
|
|
|
|
var x = a.length
|
|
|
var y = b.length
|
|
|
|
|
|
for (var i = 0, len = Math.min(x, y); i < len; ++i) {
|
|
|
if (a[i] !== b[i]) {
|
|
|
x = a[i]
|
|
|
y = b[i]
|
|
|
break
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (x < y) return -1
|
|
|
if (y < x) return 1
|
|
|
return 0
|
|
|
}
|
|
|
|
|
|
Buffer.isEncoding = function isEncoding (encoding) {
|
|
|
switch (String(encoding).toLowerCase()) {
|
|
|
case 'hex':
|
|
|
case 'utf8':
|
|
|
case 'utf-8':
|
|
|
case 'ascii':
|
|
|
case 'latin1':
|
|
|
case 'binary':
|
|
|
case 'base64':
|
|
|
case 'ucs2':
|
|
|
case 'ucs-2':
|
|
|
case 'utf16le':
|
|
|
case 'utf-16le':
|
|
|
return true
|
|
|
default:
|
|
|
return false
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Buffer.concat = function concat (list, length) {
|
|
|
if (!Array.isArray(list)) {
|
|
|
throw new TypeError('"list" argument must be an Array of Buffers')
|
|
|
}
|
|
|
|
|
|
if (list.length === 0) {
|
|
|
return Buffer.alloc(0)
|
|
|
}
|
|
|
|
|
|
var i
|
|
|
if (length === undefined) {
|
|
|
length = 0
|
|
|
for (i = 0; i < list.length; ++i) {
|
|
|
length += list[i].length
|
|
|
}
|
|
|
}
|
|
|
|
|
|
var buffer = Buffer.allocUnsafe(length)
|
|
|
var pos = 0
|
|
|
for (i = 0; i < list.length; ++i) {
|
|
|
var buf = list[i]
|
|
|
if (!Buffer.isBuffer(buf)) {
|
|
|
throw new TypeError('"list" argument must be an Array of Buffers')
|
|
|
}
|
|
|
buf.copy(buffer, pos)
|
|
|
pos += buf.length
|
|
|
}
|
|
|
return buffer
|
|
|
}
|
|
|
|
|
|
function byteLength (string, encoding) {
|
|
|
if (Buffer.isBuffer(string)) {
|
|
|
return string.length
|
|
|
}
|
|
|
if (isArrayBufferView(string) || isArrayBuffer(string)) {
|
|
|
return string.byteLength
|
|
|
}
|
|
|
if (typeof string !== 'string') {
|
|
|
string = '' + string
|
|
|
}
|
|
|
|
|
|
var len = string.length
|
|
|
if (len === 0) return 0
|
|
|
|
|
|
// Use a for loop to avoid recursion
|
|
|
var loweredCase = false
|
|
|
for (;;) {
|
|
|
switch (encoding) {
|
|
|
case 'ascii':
|
|
|
case 'latin1':
|
|
|
case 'binary':
|
|
|
return len
|
|
|
case 'utf8':
|
|
|
case 'utf-8':
|
|
|
case undefined:
|
|
|
return utf8ToBytes(string).length
|
|
|
case 'ucs2':
|
|
|
case 'ucs-2':
|
|
|
case 'utf16le':
|
|
|
case 'utf-16le':
|
|
|
return len * 2
|
|
|
case 'hex':
|
|
|
return len >>> 1
|
|
|
case 'base64':
|
|
|
return base64ToBytes(string).length
|
|
|
default:
|
|
|
if (loweredCase) return utf8ToBytes(string).length // assume utf8
|
|
|
encoding = ('' + encoding).toLowerCase()
|
|
|
loweredCase = true
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
Buffer.byteLength = byteLength
|
|
|
|
|
|
function slowToString (encoding, start, end) {
|
|
|
var loweredCase = false
|
|
|
|
|
|
// No need to verify that "this.length <= MAX_UINT32" since it's a read-only
|
|
|
// property of a typed array.
|
|
|
|
|
|
// This behaves neither like String nor Uint8Array in that we set start/end
|
|
|
// to their upper/lower bounds if the value passed is out of range.
|
|
|
// undefined is handled specially as per ECMA-262 6th Edition,
|
|
|
// Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
|
|
|
if (start === undefined || start < 0) {
|
|
|
start = 0
|
|
|
}
|
|
|
// Return early if start > this.length. Done here to prevent potential uint32
|
|
|
// coercion fail below.
|
|
|
if (start > this.length) {
|
|
|
return ''
|
|
|
}
|
|
|
|
|
|
if (end === undefined || end > this.length) {
|
|
|
end = this.length
|
|
|
}
|
|
|
|
|
|
if (end <= 0) {
|
|
|
return ''
|
|
|
}
|
|
|
|
|
|
// Force coersion to uint32. This will also coerce falsey/NaN values to 0.
|
|
|
end >>>= 0
|
|
|
start >>>= 0
|
|
|
|
|
|
if (end <= start) {
|
|
|
return ''
|
|
|
}
|
|
|
|
|
|
if (!encoding) encoding = 'utf8'
|
|
|
|
|
|
while (true) {
|
|
|
switch (encoding) {
|
|
|
case 'hex':
|
|
|
return hexSlice(this, start, end)
|
|
|
|
|
|
case 'utf8':
|
|
|
case 'utf-8':
|
|
|
return utf8Slice(this, start, end)
|
|
|
|
|
|
case 'ascii':
|
|
|
return asciiSlice(this, start, end)
|
|
|
|
|
|
case 'latin1':
|
|
|
case 'binary':
|
|
|
return latin1Slice(this, start, end)
|
|
|
|
|
|
case 'base64':
|
|
|
return base64Slice(this, start, end)
|
|
|
|
|
|
case 'ucs2':
|
|
|
case 'ucs-2':
|
|
|
case 'utf16le':
|
|
|
case 'utf-16le':
|
|
|
return utf16leSlice(this, start, end)
|
|
|
|
|
|
default:
|
|
|
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
|
|
|
encoding = (encoding + '').toLowerCase()
|
|
|
loweredCase = true
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
|
|
|
// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
|
|
|
// reliably in a browserify context because there could be multiple different
|
|
|
// copies of the 'buffer' package in use. This method works even for Buffer
|
|
|
// instances that were created from another copy of the `buffer` package.
|
|
|
// See: https://github.com/feross/buffer/issues/154
|
|
|
Buffer.prototype._isBuffer = true
|
|
|
|
|
|
function swap (b, n, m) {
|
|
|
var i = b[n]
|
|
|
b[n] = b[m]
|
|
|
b[m] = i
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.swap16 = function swap16 () {
|
|
|
var len = this.length
|
|
|
if (len % 2 !== 0) {
|
|
|
throw new RangeError('Buffer size must be a multiple of 16-bits')
|
|
|
}
|
|
|
for (var i = 0; i < len; i += 2) {
|
|
|
swap(this, i, i + 1)
|
|
|
}
|
|
|
return this
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.swap32 = function swap32 () {
|
|
|
var len = this.length
|
|
|
if (len % 4 !== 0) {
|
|
|
throw new RangeError('Buffer size must be a multiple of 32-bits')
|
|
|
}
|
|
|
for (var i = 0; i < len; i += 4) {
|
|
|
swap(this, i, i + 3)
|
|
|
swap(this, i + 1, i + 2)
|
|
|
}
|
|
|
return this
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.swap64 = function swap64 () {
|
|
|
var len = this.length
|
|
|
if (len % 8 !== 0) {
|
|
|
throw new RangeError('Buffer size must be a multiple of 64-bits')
|
|
|
}
|
|
|
for (var i = 0; i < len; i += 8) {
|
|
|
swap(this, i, i + 7)
|
|
|
swap(this, i + 1, i + 6)
|
|
|
swap(this, i + 2, i + 5)
|
|
|
swap(this, i + 3, i + 4)
|
|
|
}
|
|
|
return this
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.toString = function toString () {
|
|
|
var length = this.length
|
|
|
if (length === 0) return ''
|
|
|
if (arguments.length === 0) return utf8Slice(this, 0, length)
|
|
|
return slowToString.apply(this, arguments)
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.equals = function equals (b) {
|
|
|
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
|
|
|
if (this === b) return true
|
|
|
return Buffer.compare(this, b) === 0
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.inspect = function inspect () {
|
|
|
var str = ''
|
|
|
var max = exports.INSPECT_MAX_BYTES
|
|
|
if (this.length > 0) {
|
|
|
str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
|
|
|
if (this.length > max) str += ' ... '
|
|
|
}
|
|
|
return '<Buffer ' + str + '>'
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
|
|
|
if (!Buffer.isBuffer(target)) {
|
|
|
throw new TypeError('Argument must be a Buffer')
|
|
|
}
|
|
|
|
|
|
if (start === undefined) {
|
|
|
start = 0
|
|
|
}
|
|
|
if (end === undefined) {
|
|
|
end = target ? target.length : 0
|
|
|
}
|
|
|
if (thisStart === undefined) {
|
|
|
thisStart = 0
|
|
|
}
|
|
|
if (thisEnd === undefined) {
|
|
|
thisEnd = this.length
|
|
|
}
|
|
|
|
|
|
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
|
|
|
throw new RangeError('out of range index')
|
|
|
}
|
|
|
|
|
|
if (thisStart >= thisEnd && start >= end) {
|
|
|
return 0
|
|
|
}
|
|
|
if (thisStart >= thisEnd) {
|
|
|
return -1
|
|
|
}
|
|
|
if (start >= end) {
|
|
|
return 1
|
|
|
}
|
|
|
|
|
|
start >>>= 0
|
|
|
end >>>= 0
|
|
|
thisStart >>>= 0
|
|
|
thisEnd >>>= 0
|
|
|
|
|
|
if (this === target) return 0
|
|
|
|
|
|
var x = thisEnd - thisStart
|
|
|
var y = end - start
|
|
|
var len = Math.min(x, y)
|
|
|
|
|
|
var thisCopy = this.slice(thisStart, thisEnd)
|
|
|
var targetCopy = target.slice(start, end)
|
|
|
|
|
|
for (var i = 0; i < len; ++i) {
|
|
|
if (thisCopy[i] !== targetCopy[i]) {
|
|
|
x = thisCopy[i]
|
|
|
y = targetCopy[i]
|
|
|
break
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (x < y) return -1
|
|
|
if (y < x) return 1
|
|
|
return 0
|
|
|
}
|
|
|
|
|
|
// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
|
|
|
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
|
|
|
//
|
|
|
// Arguments:
|
|
|
// - buffer - a Buffer to search
|
|
|
// - val - a string, Buffer, or number
|
|
|
// - byteOffset - an index into `buffer`; will be clamped to an int32
|
|
|
// - encoding - an optional encoding, relevant is val is a string
|
|
|
// - dir - true for indexOf, false for lastIndexOf
|
|
|
function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
|
|
|
// Empty buffer means no match
|
|
|
if (buffer.length === 0) return -1
|
|
|
|
|
|
// Normalize byteOffset
|
|
|
if (typeof byteOffset === 'string') {
|
|
|
encoding = byteOffset
|
|
|
byteOffset = 0
|
|
|
} else if (byteOffset > 0x7fffffff) {
|
|
|
byteOffset = 0x7fffffff
|
|
|
} else if (byteOffset < -0x80000000) {
|
|
|
byteOffset = -0x80000000
|
|
|
}
|
|
|
byteOffset = +byteOffset // Coerce to Number.
|
|
|
if (numberIsNaN(byteOffset)) {
|
|
|
// byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
|
|
|
byteOffset = dir ? 0 : (buffer.length - 1)
|
|
|
}
|
|
|
|
|
|
// Normalize byteOffset: negative offsets start from the end of the buffer
|
|
|
if (byteOffset < 0) byteOffset = buffer.length + byteOffset
|
|
|
if (byteOffset >= buffer.length) {
|
|
|
if (dir) return -1
|
|
|
else byteOffset = buffer.length - 1
|
|
|
} else if (byteOffset < 0) {
|
|
|
if (dir) byteOffset = 0
|
|
|
else return -1
|
|
|
}
|
|
|
|
|
|
// Normalize val
|
|
|
if (typeof val === 'string') {
|
|
|
val = Buffer.from(val, encoding)
|
|
|
}
|
|
|
|
|
|
// Finally, search either indexOf (if dir is true) or lastIndexOf
|
|
|
if (Buffer.isBuffer(val)) {
|
|
|
// Special case: looking for empty string/buffer always fails
|
|
|
if (val.length === 0) {
|
|
|
return -1
|
|
|
}
|
|
|
return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
|
|
|
} else if (typeof val === 'number') {
|
|
|
val = val & 0xFF // Search for a byte value [0-255]
|
|
|
if (typeof Uint8Array.prototype.indexOf === 'function') {
|
|
|
if (dir) {
|
|
|
return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
|
|
|
} else {
|
|
|
return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
|
|
|
}
|
|
|
}
|
|
|
return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
|
|
|
}
|
|
|
|
|
|
throw new TypeError('val must be string, number or Buffer')
|
|
|
}
|
|
|
|
|
|
function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
|
|
|
var indexSize = 1
|
|
|
var arrLength = arr.length
|
|
|
var valLength = val.length
|
|
|
|
|
|
if (encoding !== undefined) {
|
|
|
encoding = String(encoding).toLowerCase()
|
|
|
if (encoding === 'ucs2' || encoding === 'ucs-2' ||
|
|
|
encoding === 'utf16le' || encoding === 'utf-16le') {
|
|
|
if (arr.length < 2 || val.length < 2) {
|
|
|
return -1
|
|
|
}
|
|
|
indexSize = 2
|
|
|
arrLength /= 2
|
|
|
valLength /= 2
|
|
|
byteOffset /= 2
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function read (buf, i) {
|
|
|
if (indexSize === 1) {
|
|
|
return buf[i]
|
|
|
} else {
|
|
|
return buf.readUInt16BE(i * indexSize)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
var i
|
|
|
if (dir) {
|
|
|
var foundIndex = -1
|
|
|
for (i = byteOffset; i < arrLength; i++) {
|
|
|
if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
|
|
|
if (foundIndex === -1) foundIndex = i
|
|
|
if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
|
|
|
} else {
|
|
|
if (foundIndex !== -1) i -= i - foundIndex
|
|
|
foundIndex = -1
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
|
|
|
for (i = byteOffset; i >= 0; i--) {
|
|
|
var found = true
|
|
|
for (var j = 0; j < valLength; j++) {
|
|
|
if (read(arr, i + j) !== read(val, j)) {
|
|
|
found = false
|
|
|
break
|
|
|
}
|
|
|
}
|
|
|
if (found) return i
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return -1
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
|
|
|
return this.indexOf(val, byteOffset, encoding) !== -1
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
|
|
|
return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
|
|
|
return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
|
|
|
}
|
|
|
|
|
|
function hexWrite (buf, string, offset, length) {
|
|
|
offset = Number(offset) || 0
|
|
|
var remaining = buf.length - offset
|
|
|
if (!length) {
|
|
|
length = remaining
|
|
|
} else {
|
|
|
length = Number(length)
|
|
|
if (length > remaining) {
|
|
|
length = remaining
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// must be an even number of digits
|
|
|
var strLen = string.length
|
|
|
if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
|
|
|
|
|
|
if (length > strLen / 2) {
|
|
|
length = strLen / 2
|
|
|
}
|
|
|
for (var i = 0; i < length; ++i) {
|
|
|
var parsed = parseInt(string.substr(i * 2, 2), 16)
|
|
|
if (numberIsNaN(parsed)) return i
|
|
|
buf[offset + i] = parsed
|
|
|
}
|
|
|
return i
|
|
|
}
|
|
|
|
|
|
function utf8Write (buf, string, offset, length) {
|
|
|
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
|
|
|
}
|
|
|
|
|
|
function asciiWrite (buf, string, offset, length) {
|
|
|
return blitBuffer(asciiToBytes(string), buf, offset, length)
|
|
|
}
|
|
|
|
|
|
function latin1Write (buf, string, offset, length) {
|
|
|
return asciiWrite(buf, string, offset, length)
|
|
|
}
|
|
|
|
|
|
function base64Write (buf, string, offset, length) {
|
|
|
return blitBuffer(base64ToBytes(string), buf, offset, length)
|
|
|
}
|
|
|
|
|
|
function ucs2Write (buf, string, offset, length) {
|
|
|
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.write = function write (string, offset, length, encoding) {
|
|
|
// Buffer#write(string)
|
|
|
if (offset === undefined) {
|
|
|
encoding = 'utf8'
|
|
|
length = this.length
|
|
|
offset = 0
|
|
|
// Buffer#write(string, encoding)
|
|
|
} else if (length === undefined && typeof offset === 'string') {
|
|
|
encoding = offset
|
|
|
length = this.length
|
|
|
offset = 0
|
|
|
// Buffer#write(string, offset[, length][, encoding])
|
|
|
} else if (isFinite(offset)) {
|
|
|
offset = offset >>> 0
|
|
|
if (isFinite(length)) {
|
|
|
length = length >>> 0
|
|
|
if (encoding === undefined) encoding = 'utf8'
|
|
|
} else {
|
|
|
encoding = length
|
|
|
length = undefined
|
|
|
}
|
|
|
} else {
|
|
|
throw new Error(
|
|
|
'Buffer.write(string, encoding, offset[, length]) is no longer supported'
|
|
|
)
|
|
|
}
|
|
|
|
|
|
var remaining = this.length - offset
|
|
|
if (length === undefined || length > remaining) length = remaining
|
|
|
|
|
|
if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
|
|
|
throw new RangeError('Attempt to write outside buffer bounds')
|
|
|
}
|
|
|
|
|
|
if (!encoding) encoding = 'utf8'
|
|
|
|
|
|
var loweredCase = false
|
|
|
for (;;) {
|
|
|
switch (encoding) {
|
|
|
case 'hex':
|
|
|
return hexWrite(this, string, offset, length)
|
|
|
|
|
|
case 'utf8':
|
|
|
case 'utf-8':
|
|
|
return utf8Write(this, string, offset, length)
|
|
|
|
|
|
case 'ascii':
|
|
|
return asciiWrite(this, string, offset, length)
|
|
|
|
|
|
case 'latin1':
|
|
|
case 'binary':
|
|
|
return latin1Write(this, string, offset, length)
|
|
|
|
|
|
case 'base64':
|
|
|
// Warning: maxLength not taken into account in base64Write
|
|
|
return base64Write(this, string, offset, length)
|
|
|
|
|
|
case 'ucs2':
|
|
|
case 'ucs-2':
|
|
|
case 'utf16le':
|
|
|
case 'utf-16le':
|
|
|
return ucs2Write(this, string, offset, length)
|
|
|
|
|
|
default:
|
|
|
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
|
|
|
encoding = ('' + encoding).toLowerCase()
|
|
|
loweredCase = true
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.toJSON = function toJSON () {
|
|
|
return {
|
|
|
type: 'Buffer',
|
|
|
data: Array.prototype.slice.call(this._arr || this, 0)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function base64Slice (buf, start, end) {
|
|
|
if (start === 0 && end === buf.length) {
|
|
|
return base64.fromByteArray(buf)
|
|
|
} else {
|
|
|
return base64.fromByteArray(buf.slice(start, end))
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function utf8Slice (buf, start, end) {
|
|
|
end = Math.min(buf.length, end)
|
|
|
var res = []
|
|
|
|
|
|
var i = start
|
|
|
while (i < end) {
|
|
|
var firstByte = buf[i]
|
|
|
var codePoint = null
|
|
|
var bytesPerSequence = (firstByte > 0xEF) ? 4
|
|
|
: (firstByte > 0xDF) ? 3
|
|
|
: (firstByte > 0xBF) ? 2
|
|
|
: 1
|
|
|
|
|
|
if (i + bytesPerSequence <= end) {
|
|
|
var secondByte, thirdByte, fourthByte, tempCodePoint
|
|
|
|
|
|
switch (bytesPerSequence) {
|
|
|
case 1:
|
|
|
if (firstByte < 0x80) {
|
|
|
codePoint = firstByte
|
|
|
}
|
|
|
break
|
|
|
case 2:
|
|
|
secondByte = buf[i + 1]
|
|
|
if ((secondByte & 0xC0) === 0x80) {
|
|
|
tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
|
|
|
if (tempCodePoint > 0x7F) {
|
|
|
codePoint = tempCodePoint
|
|
|
}
|
|
|
}
|
|
|
break
|
|
|
case 3:
|
|
|
secondByte = buf[i + 1]
|
|
|
thirdByte = buf[i + 2]
|
|
|
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
|
|
|
tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
|
|
|
if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
|
|
|
codePoint = tempCodePoint
|
|
|
}
|
|
|
}
|
|
|
break
|
|
|
case 4:
|
|
|
secondByte = buf[i + 1]
|
|
|
thirdByte = buf[i + 2]
|
|
|
fourthByte = buf[i + 3]
|
|
|
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
|
|
|
tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
|
|
|
if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
|
|
|
codePoint = tempCodePoint
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (codePoint === null) {
|
|
|
// we did not generate a valid codePoint so insert a
|
|
|
// replacement char (U+FFFD) and advance only 1 byte
|
|
|
codePoint = 0xFFFD
|
|
|
bytesPerSequence = 1
|
|
|
} else if (codePoint > 0xFFFF) {
|
|
|
// encode to utf16 (surrogate pair dance)
|
|
|
codePoint -= 0x10000
|
|
|
res.push(codePoint >>> 10 & 0x3FF | 0xD800)
|
|
|
codePoint = 0xDC00 | codePoint & 0x3FF
|
|
|
}
|
|
|
|
|
|
res.push(codePoint)
|
|
|
i += bytesPerSequence
|
|
|
}
|
|
|
|
|
|
return decodeCodePointsArray(res)
|
|
|
}
|
|
|
|
|
|
// Based on http://stackoverflow.com/a/22747272/680742, the browser with
|
|
|
// the lowest limit is Chrome, with 0x10000 args.
|
|
|
// We go 1 magnitude less, for safety
|
|
|
var MAX_ARGUMENTS_LENGTH = 0x1000
|
|
|
|
|
|
function decodeCodePointsArray (codePoints) {
|
|
|
var len = codePoints.length
|
|
|
if (len <= MAX_ARGUMENTS_LENGTH) {
|
|
|
return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
|
|
|
}
|
|
|
|
|
|
// Decode in chunks to avoid "call stack size exceeded".
|
|
|
var res = ''
|
|
|
var i = 0
|
|
|
while (i < len) {
|
|
|
res += String.fromCharCode.apply(
|
|
|
String,
|
|
|
codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
|
|
|
)
|
|
|
}
|
|
|
return res
|
|
|
}
|
|
|
|
|
|
function asciiSlice (buf, start, end) {
|
|
|
var ret = ''
|
|
|
end = Math.min(buf.length, end)
|
|
|
|
|
|
for (var i = start; i < end; ++i) {
|
|
|
ret += String.fromCharCode(buf[i] & 0x7F)
|
|
|
}
|
|
|
return ret
|
|
|
}
|
|
|
|
|
|
function latin1Slice (buf, start, end) {
|
|
|
var ret = ''
|
|
|
end = Math.min(buf.length, end)
|
|
|
|
|
|
for (var i = start; i < end; ++i) {
|
|
|
ret += String.fromCharCode(buf[i])
|
|
|
}
|
|
|
return ret
|
|
|
}
|
|
|
|
|
|
function hexSlice (buf, start, end) {
|
|
|
var len = buf.length
|
|
|
|
|
|
if (!start || start < 0) start = 0
|
|
|
if (!end || end < 0 || end > len) end = len
|
|
|
|
|
|
var out = ''
|
|
|
for (var i = start; i < end; ++i) {
|
|
|
out += toHex(buf[i])
|
|
|
}
|
|
|
return out
|
|
|
}
|
|
|
|
|
|
function utf16leSlice (buf, start, end) {
|
|
|
var bytes = buf.slice(start, end)
|
|
|
var res = ''
|
|
|
for (var i = 0; i < bytes.length; i += 2) {
|
|
|
res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
|
|
|
}
|
|
|
return res
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.slice = function slice (start, end) {
|
|
|
var len = this.length
|
|
|
start = ~~start
|
|
|
end = end === undefined ? len : ~~end
|
|
|
|
|
|
if (start < 0) {
|
|
|
start += len
|
|
|
if (start < 0) start = 0
|
|
|
} else if (start > len) {
|
|
|
start = len
|
|
|
}
|
|
|
|
|
|
if (end < 0) {
|
|
|
end += len
|
|
|
if (end < 0) end = 0
|
|
|
} else if (end > len) {
|
|
|
end = len
|
|
|
}
|
|
|
|
|
|
if (end < start) end = start
|
|
|
|
|
|
var newBuf = this.subarray(start, end)
|
|
|
// Return an augmented `Uint8Array` instance
|
|
|
newBuf.__proto__ = Buffer.prototype
|
|
|
return newBuf
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Need to make sure that buffer isn't trying to write out of bounds.
|
|
|
*/
|
|
|
function checkOffset (offset, ext, length) {
|
|
|
if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
|
|
|
if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
byteLength = byteLength >>> 0
|
|
|
if (!noAssert) checkOffset(offset, byteLength, this.length)
|
|
|
|
|
|
var val = this[offset]
|
|
|
var mul = 1
|
|
|
var i = 0
|
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
|
val += this[offset + i] * mul
|
|
|
}
|
|
|
|
|
|
return val
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
byteLength = byteLength >>> 0
|
|
|
if (!noAssert) {
|
|
|
checkOffset(offset, byteLength, this.length)
|
|
|
}
|
|
|
|
|
|
var val = this[offset + --byteLength]
|
|
|
var mul = 1
|
|
|
while (byteLength > 0 && (mul *= 0x100)) {
|
|
|
val += this[offset + --byteLength] * mul
|
|
|
}
|
|
|
|
|
|
return val
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkOffset(offset, 1, this.length)
|
|
|
return this[offset]
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
|
|
return this[offset] | (this[offset + 1] << 8)
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
|
|
return (this[offset] << 8) | this[offset + 1]
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
|
|
|
|
return ((this[offset]) |
|
|
|
(this[offset + 1] << 8) |
|
|
|
(this[offset + 2] << 16)) +
|
|
|
(this[offset + 3] * 0x1000000)
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
|
|
|
|
return (this[offset] * 0x1000000) +
|
|
|
((this[offset + 1] << 16) |
|
|
|
(this[offset + 2] << 8) |
|
|
|
this[offset + 3])
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
byteLength = byteLength >>> 0
|
|
|
if (!noAssert) checkOffset(offset, byteLength, this.length)
|
|
|
|
|
|
var val = this[offset]
|
|
|
var mul = 1
|
|
|
var i = 0
|
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
|
val += this[offset + i] * mul
|
|
|
}
|
|
|
mul *= 0x80
|
|
|
|
|
|
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
|
|
|
|
|
|
return val
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
byteLength = byteLength >>> 0
|
|
|
if (!noAssert) checkOffset(offset, byteLength, this.length)
|
|
|
|
|
|
var i = byteLength
|
|
|
var mul = 1
|
|
|
var val = this[offset + --i]
|
|
|
while (i > 0 && (mul *= 0x100)) {
|
|
|
val += this[offset + --i] * mul
|
|
|
}
|
|
|
mul *= 0x80
|
|
|
|
|
|
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
|
|
|
|
|
|
return val
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkOffset(offset, 1, this.length)
|
|
|
if (!(this[offset] & 0x80)) return (this[offset])
|
|
|
return ((0xff - this[offset] + 1) * -1)
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
|
|
var val = this[offset] | (this[offset + 1] << 8)
|
|
|
return (val & 0x8000) ? val | 0xFFFF0000 : val
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
|
|
var val = this[offset + 1] | (this[offset] << 8)
|
|
|
return (val & 0x8000) ? val | 0xFFFF0000 : val
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
|
|
|
|
return (this[offset]) |
|
|
|
(this[offset + 1] << 8) |
|
|
|
(this[offset + 2] << 16) |
|
|
|
(this[offset + 3] << 24)
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
|
|
|
|
return (this[offset] << 24) |
|
|
|
(this[offset + 1] << 16) |
|
|
|
(this[offset + 2] << 8) |
|
|
|
(this[offset + 3])
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
|
return ieee754.read(this, offset, true, 23, 4)
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
|
return ieee754.read(this, offset, false, 23, 4)
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkOffset(offset, 8, this.length)
|
|
|
return ieee754.read(this, offset, true, 52, 8)
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkOffset(offset, 8, this.length)
|
|
|
return ieee754.read(this, offset, false, 52, 8)
|
|
|
}
|
|
|
|
|
|
function checkInt (buf, value, offset, ext, max, min) {
|
|
|
if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
|
|
|
if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
|
|
|
if (offset + ext > buf.length) throw new RangeError('Index out of range')
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
byteLength = byteLength >>> 0
|
|
|
if (!noAssert) {
|
|
|
var maxBytes = Math.pow(2, 8 * byteLength) - 1
|
|
|
checkInt(this, value, offset, byteLength, maxBytes, 0)
|
|
|
}
|
|
|
|
|
|
var mul = 1
|
|
|
var i = 0
|
|
|
this[offset] = value & 0xFF
|
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
|
this[offset + i] = (value / mul) & 0xFF
|
|
|
}
|
|
|
|
|
|
return offset + byteLength
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
byteLength = byteLength >>> 0
|
|
|
if (!noAssert) {
|
|
|
var maxBytes = Math.pow(2, 8 * byteLength) - 1
|
|
|
checkInt(this, value, offset, byteLength, maxBytes, 0)
|
|
|
}
|
|
|
|
|
|
var i = byteLength - 1
|
|
|
var mul = 1
|
|
|
this[offset + i] = value & 0xFF
|
|
|
while (--i >= 0 && (mul *= 0x100)) {
|
|
|
this[offset + i] = (value / mul) & 0xFF
|
|
|
}
|
|
|
|
|
|
return offset + byteLength
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
|
|
|
this[offset] = (value & 0xff)
|
|
|
return offset + 1
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
|
|
|
this[offset] = (value & 0xff)
|
|
|
this[offset + 1] = (value >>> 8)
|
|
|
return offset + 2
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
|
|
|
this[offset] = (value >>> 8)
|
|
|
this[offset + 1] = (value & 0xff)
|
|
|
return offset + 2
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
|
|
|
this[offset + 3] = (value >>> 24)
|
|
|
this[offset + 2] = (value >>> 16)
|
|
|
this[offset + 1] = (value >>> 8)
|
|
|
this[offset] = (value & 0xff)
|
|
|
return offset + 4
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
|
|
|
this[offset] = (value >>> 24)
|
|
|
this[offset + 1] = (value >>> 16)
|
|
|
this[offset + 2] = (value >>> 8)
|
|
|
this[offset + 3] = (value & 0xff)
|
|
|
return offset + 4
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) {
|
|
|
var limit = Math.pow(2, (8 * byteLength) - 1)
|
|
|
|
|
|
checkInt(this, value, offset, byteLength, limit - 1, -limit)
|
|
|
}
|
|
|
|
|
|
var i = 0
|
|
|
var mul = 1
|
|
|
var sub = 0
|
|
|
this[offset] = value & 0xFF
|
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
|
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
|
|
|
sub = 1
|
|
|
}
|
|
|
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
|
|
|
}
|
|
|
|
|
|
return offset + byteLength
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) {
|
|
|
var limit = Math.pow(2, (8 * byteLength) - 1)
|
|
|
|
|
|
checkInt(this, value, offset, byteLength, limit - 1, -limit)
|
|
|
}
|
|
|
|
|
|
var i = byteLength - 1
|
|
|
var mul = 1
|
|
|
var sub = 0
|
|
|
this[offset + i] = value & 0xFF
|
|
|
while (--i >= 0 && (mul *= 0x100)) {
|
|
|
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
|
|
|
sub = 1
|
|
|
}
|
|
|
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
|
|
|
}
|
|
|
|
|
|
return offset + byteLength
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
|
|
|
if (value < 0) value = 0xff + value + 1
|
|
|
this[offset] = (value & 0xff)
|
|
|
return offset + 1
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
|
|
|
this[offset] = (value & 0xff)
|
|
|
this[offset + 1] = (value >>> 8)
|
|
|
return offset + 2
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
|
|
|
this[offset] = (value >>> 8)
|
|
|
this[offset + 1] = (value & 0xff)
|
|
|
return offset + 2
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
|
|
|
this[offset] = (value & 0xff)
|
|
|
this[offset + 1] = (value >>> 8)
|
|
|
this[offset + 2] = (value >>> 16)
|
|
|
this[offset + 3] = (value >>> 24)
|
|
|
return offset + 4
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
|
|
|
if (value < 0) value = 0xffffffff + value + 1
|
|
|
this[offset] = (value >>> 24)
|
|
|
this[offset + 1] = (value >>> 16)
|
|
|
this[offset + 2] = (value >>> 8)
|
|
|
this[offset + 3] = (value & 0xff)
|
|
|
return offset + 4
|
|
|
}
|
|
|
|
|
|
function checkIEEE754 (buf, value, offset, ext, max, min) {
|
|
|
if (offset + ext > buf.length) throw new RangeError('Index out of range')
|
|
|
if (offset < 0) throw new RangeError('Index out of range')
|
|
|
}
|
|
|
|
|
|
function writeFloat (buf, value, offset, littleEndian, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) {
|
|
|
checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
|
|
|
}
|
|
|
ieee754.write(buf, value, offset, littleEndian, 23, 4)
|
|
|
return offset + 4
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
|
|
|
return writeFloat(this, value, offset, true, noAssert)
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
|
|
|
return writeFloat(this, value, offset, false, noAssert)
|
|
|
}
|
|
|
|
|
|
function writeDouble (buf, value, offset, littleEndian, noAssert) {
|
|
|
value = +value
|
|
|
offset = offset >>> 0
|
|
|
if (!noAssert) {
|
|
|
checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
|
|
|
}
|
|
|
ieee754.write(buf, value, offset, littleEndian, 52, 8)
|
|
|
return offset + 8
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
|
|
|
return writeDouble(this, value, offset, true, noAssert)
|
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
|
|
|
return writeDouble(this, value, offset, false, noAssert)
|
|
|
}
|
|
|
|
|
|
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
|
|
|
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
|
|
|
if (!start) start = 0
|
|
|
if (!end && end !== 0) end = this.length
|
|
|
if (targetStart >= target.length) targetStart = target.length
|
|
|
if (!targetStart) targetStart = 0
|
|
|
if (end > 0 && end < start) end = start
|
|
|
|
|
|
// Copy 0 bytes; we're done
|
|
|
if (end === start) return 0
|
|
|
if (target.length === 0 || this.length === 0) return 0
|
|
|
|
|
|
// Fatal error conditions
|
|
|
if (targetStart < 0) {
|
|
|
throw new RangeError('targetStart out of bounds')
|
|
|
}
|
|
|
if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
|
|
|
if (end < 0) throw new RangeError('sourceEnd out of bounds')
|
|
|
|
|
|
// Are we oob?
|
|
|
if (end > this.length) end = this.length
|
|
|
if (target.length - targetStart < end - start) {
|
|
|
end = target.length - targetStart + start
|
|
|
}
|
|
|
|
|
|
var len = end - start
|
|
|
var i
|
|
|
|
|
|
if (this === target && start < targetStart && targetStart < end) {
|
|
|
// descending copy from end
|
|
|
for (i = len - 1; i >= 0; --i) {
|
|
|
target[i + targetStart] = this[i + start]
|
|
|
}
|
|
|
} else if (len < 1000) {
|
|
|
// ascending copy from start
|
|
|
for (i = 0; i < len; ++i) {
|
|
|
target[i + targetStart] = this[i + start]
|
|
|
}
|
|
|
} else {
|
|
|
Uint8Array.prototype.set.call(
|
|
|
target,
|
|
|
this.subarray(start, start + len),
|
|
|
targetStart
|
|
|
)
|
|
|
}
|
|
|
|
|
|
return len
|
|
|
}
|
|
|
|
|
|
// Usage:
|
|
|
// buffer.fill(number[, offset[, end]])
|
|
|
// buffer.fill(buffer[, offset[, end]])
|
|
|
// buffer.fill(string[, offset[, end]][, encoding])
|
|
|
Buffer.prototype.fill = function fill (val, start, end, encoding) {
|
|
|
// Handle string cases:
|
|
|
if (typeof val === 'string') {
|
|
|
if (typeof start === 'string') {
|
|
|
encoding = start
|
|
|
start = 0
|
|
|
end = this.length
|
|
|
} else if (typeof end === 'string') {
|
|
|
encoding = end
|
|
|
end = this.length
|
|
|
}
|
|
|
if (val.length === 1) {
|
|
|
var code = val.charCodeAt(0)
|
|
|
if (code < 256) {
|
|
|
val = code
|
|
|
}
|
|
|
}
|
|
|
if (encoding !== undefined && typeof encoding !== 'string') {
|
|
|
throw new TypeError('encoding must be a string')
|
|
|
}
|
|
|
if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
|
|
|
throw new TypeError('Unknown encoding: ' + encoding)
|
|
|
}
|
|
|
} else if (typeof val === 'number') {
|
|
|
val = val & 255
|
|
|
}
|
|
|
|
|
|
// Invalid ranges are not set to a default, so can range check early.
|
|
|
if (start < 0 || this.length < start || this.length < end) {
|
|
|
throw new RangeError('Out of range index')
|
|
|
}
|
|
|
|
|
|
if (end <= start) {
|
|
|
return this
|
|
|
}
|
|
|
|
|
|
start = start >>> 0
|
|
|
end = end === undefined ? this.length : end >>> 0
|
|
|
|
|
|
if (!val) val = 0
|
|
|
|
|
|
var i
|
|
|
if (typeof val === 'number') {
|
|
|
for (i = start; i < end; ++i) {
|
|
|
this[i] = val
|
|
|
}
|
|
|
} else {
|
|
|
var bytes = Buffer.isBuffer(val)
|
|
|
? val
|
|
|
: new Buffer(val, encoding)
|
|
|
var len = bytes.length
|
|
|
for (i = 0; i < end - start; ++i) {
|
|
|
this[i + start] = bytes[i % len]
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return this
|
|
|
}
|
|
|
|
|
|
// HELPER FUNCTIONS
|
|
|
// ================
|
|
|
|
|
|
var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
|
|
|
|
|
|
function base64clean (str) {
|
|
|
// Node strips out invalid characters like \n and \t from the string, base64-js does not
|
|
|
str = str.trim().replace(INVALID_BASE64_RE, '')
|
|
|
// Node converts strings with length < 2 to ''
|
|
|
if (str.length < 2) return ''
|
|
|
// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
|
|
|
while (str.length % 4 !== 0) {
|
|
|
str = str + '='
|
|
|
}
|
|
|
return str
|
|
|
}
|
|
|
|
|
|
function toHex (n) {
|
|
|
if (n < 16) return '0' + n.toString(16)
|
|
|
return n.toString(16)
|
|
|
}
|
|
|
|
|
|
function utf8ToBytes (string, units) {
|
|
|
units = units || Infinity
|
|
|
var codePoint
|
|
|
var length = string.length
|
|
|
var leadSurrogate = null
|
|
|
var bytes = []
|
|
|
|
|
|
for (var i = 0; i < length; ++i) {
|
|
|
codePoint = string.charCodeAt(i)
|
|
|
|
|
|
// is surrogate component
|
|
|
if (codePoint > 0xD7FF && codePoint < 0xE000) {
|
|
|
// last char was a lead
|
|
|
if (!leadSurrogate) {
|
|
|
// no lead yet
|
|
|
if (codePoint > 0xDBFF) {
|
|
|
// unexpected trail
|
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
|
|
continue
|
|
|
} else if (i + 1 === length) {
|
|
|
// unpaired lead
|
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
|
|
continue
|
|
|
}
|
|
|
|
|
|
// valid lead
|
|
|
leadSurrogate = codePoint
|
|
|
|
|
|
continue
|
|
|
}
|
|
|
|
|
|
// 2 leads in a row
|
|
|
if (codePoint < 0xDC00) {
|
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
|
|
leadSurrogate = codePoint
|
|
|
continue
|
|
|
}
|
|
|
|
|
|
// valid surrogate pair
|
|
|
codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
|
|
|
} else if (leadSurrogate) {
|
|
|
// valid bmp char, but last char was a lead
|
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
|
|
}
|
|
|
|
|
|
leadSurrogate = null
|
|
|
|
|
|
// encode utf8
|
|
|
if (codePoint < 0x80) {
|
|
|
if ((units -= 1) < 0) break
|
|
|
bytes.push(codePoint)
|
|
|
} else if (codePoint < 0x800) {
|
|
|
if ((units -= 2) < 0) break
|
|
|
bytes.push(
|
|
|
codePoint >> 0x6 | 0xC0,
|
|
|
codePoint & 0x3F | 0x80
|
|
|
)
|
|
|
} else if (codePoint < 0x10000) {
|
|
|
if ((units -= 3) < 0) break
|
|
|
bytes.push(
|
|
|
codePoint >> 0xC | 0xE0,
|
|
|
codePoint >> 0x6 & 0x3F | 0x80,
|
|
|
codePoint & 0x3F | 0x80
|
|
|
)
|
|
|
} else if (codePoint < 0x110000) {
|
|
|
if ((units -= 4) < 0) break
|
|
|
bytes.push(
|
|
|
codePoint >> 0x12 | 0xF0,
|
|
|
codePoint >> 0xC & 0x3F | 0x80,
|
|
|
codePoint >> 0x6 & 0x3F | 0x80,
|
|
|
codePoint & 0x3F | 0x80
|
|
|
)
|
|
|
} else {
|
|
|
throw new Error('Invalid code point')
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return bytes
|
|
|
}
|
|
|
|
|
|
function asciiToBytes (str) {
|
|
|
var byteArray = []
|
|
|
for (var i = 0; i < str.length; ++i) {
|
|
|
// Node's code seems to be doing this and not & 0x7F..
|
|
|
byteArray.push(str.charCodeAt(i) & 0xFF)
|
|
|
}
|
|
|
return byteArray
|
|
|
}
|
|
|
|
|
|
function utf16leToBytes (str, units) {
|
|
|
var c, hi, lo
|
|
|
var byteArray = []
|
|
|
for (var i = 0; i < str.length; ++i) {
|
|
|
if ((units -= 2) < 0) break
|
|
|
|
|
|
c = str.charCodeAt(i)
|
|
|
hi = c >> 8
|
|
|
lo = c % 256
|
|
|
byteArray.push(lo)
|
|
|
byteArray.push(hi)
|
|
|
}
|
|
|
|
|
|
return byteArray
|
|
|
}
|
|
|
|
|
|
function base64ToBytes (str) {
|
|
|
return base64.toByteArray(base64clean(str))
|
|
|
}
|
|
|
|
|
|
function blitBuffer (src, dst, offset, length) {
|
|
|
for (var i = 0; i < length; ++i) {
|
|
|
if ((i + offset >= dst.length) || (i >= src.length)) break
|
|
|
dst[i + offset] = src[i]
|
|
|
}
|
|
|
return i
|
|
|
}
|
|
|
|
|
|
// ArrayBuffers from another context (i.e. an iframe) do not pass the `instanceof` check
|
|
|
// but they should be treated as valid. See: https://github.com/feross/buffer/issues/166
|
|
|
function isArrayBuffer (obj) {
|
|
|
return obj instanceof ArrayBuffer ||
|
|
|
(obj != null && obj.constructor != null && obj.constructor.name === 'ArrayBuffer' &&
|
|
|
typeof obj.byteLength === 'number')
|
|
|
}
|
|
|
|
|
|
// Node 0.10 supports `ArrayBuffer` but lacks `ArrayBuffer.isView`
|
|
|
function isArrayBufferView (obj) {
|
|
|
return (typeof ArrayBuffer.isView === 'function') && ArrayBuffer.isView(obj)
|
|
|
}
|
|
|
|
|
|
function numberIsNaN (obj) {
|
|
|
return obj !== obj // eslint-disable-line no-self-compare
|
|
|
}
|
|
|
|
|
|
},{"base64-js":1,"ieee754":3}],3:[function(require,module,exports){
|
|
|
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
|
|
|
var e, m
|
|
|
var eLen = nBytes * 8 - mLen - 1
|
|
|
var eMax = (1 << eLen) - 1
|
|
|
var eBias = eMax >> 1
|
|
|
var nBits = -7
|
|
|
var i = isLE ? (nBytes - 1) : 0
|
|
|
var d = isLE ? -1 : 1
|
|
|
var s = buffer[offset + i]
|
|
|
|
|
|
i += d
|
|
|
|
|
|
e = s & ((1 << (-nBits)) - 1)
|
|
|
s >>= (-nBits)
|
|
|
nBits += eLen
|
|
|
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
|
|
|
|
|
|
m = e & ((1 << (-nBits)) - 1)
|
|
|
e >>= (-nBits)
|
|
|
nBits += mLen
|
|
|
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
|
|
|
|
|
|
if (e === 0) {
|
|
|
e = 1 - eBias
|
|
|
} else if (e === eMax) {
|
|
|
return m ? NaN : ((s ? -1 : 1) * Infinity)
|
|
|
} else {
|
|
|
m = m + Math.pow(2, mLen)
|
|
|
e = e - eBias
|
|
|
}
|
|
|
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
|
|
|
}
|
|
|
|
|
|
exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
|
|
|
var e, m, c
|
|
|
var eLen = nBytes * 8 - mLen - 1
|
|
|
var eMax = (1 << eLen) - 1
|
|
|
var eBias = eMax >> 1
|
|
|
var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
|
|
|
var i = isLE ? 0 : (nBytes - 1)
|
|
|
var d = isLE ? 1 : -1
|
|
|
var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
|
|
|
|
|
|
value = Math.abs(value)
|
|
|
|
|
|
if (isNaN(value) || value === Infinity) {
|
|
|
m = isNaN(value) ? 1 : 0
|
|
|
e = eMax
|
|
|
} else {
|
|
|
e = Math.floor(Math.log(value) / Math.LN2)
|
|
|
if (value * (c = Math.pow(2, -e)) < 1) {
|
|
|
e--
|
|
|
c *= 2
|
|
|
}
|
|
|
if (e + eBias >= 1) {
|
|
|
value += rt / c
|
|
|
} else {
|
|
|
value += rt * Math.pow(2, 1 - eBias)
|
|
|
}
|
|
|
if (value * c >= 2) {
|
|
|
e++
|
|
|
c /= 2
|
|
|
}
|
|
|
|
|
|
if (e + eBias >= eMax) {
|
|
|
m = 0
|
|
|
e = eMax
|
|
|
} else if (e + eBias >= 1) {
|
|
|
m = (value * c - 1) * Math.pow(2, mLen)
|
|
|
e = e + eBias
|
|
|
} else {
|
|
|
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
|
|
|
e = 0
|
|
|
}
|
|
|
}
|
|
|
|
|
|
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
|
|
|
|
|
|
e = (e << mLen) | m
|
|
|
eLen += mLen
|
|
|
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
|
|
|
|
|
|
buffer[offset + i - d] |= s * 128
|
|
|
}
|
|
|
|
|
|
},{}],4:[function(require,module,exports){
|
|
|
// shim for using process in browser
|
|
|
var process = module.exports = {};
|
|
|
|
|
|
// cached from whatever global is present so that test runners that stub it
|
|
|
// don't break things. But we need to wrap it in a try catch in case it is
|
|
|
// wrapped in strict mode code which doesn't define any globals. It's inside a
|
|
|
// function because try/catches deoptimize in certain engines.
|
|
|
|
|
|
var cachedSetTimeout;
|
|
|
var cachedClearTimeout;
|
|
|
|
|
|
function defaultSetTimout() {
|
|
|
throw new Error('setTimeout has not been defined');
|
|
|
}
|
|
|
function defaultClearTimeout () {
|
|
|
throw new Error('clearTimeout has not been defined');
|
|
|
}
|
|
|
(function () {
|
|
|
try {
|
|
|
if (typeof setTimeout === 'function') {
|
|
|
cachedSetTimeout = setTimeout;
|
|
|
} else {
|
|
|
cachedSetTimeout = defaultSetTimout;
|
|
|
}
|
|
|
} catch (e) {
|
|
|
cachedSetTimeout = defaultSetTimout;
|
|
|
}
|
|
|
try {
|
|
|
if (typeof clearTimeout === 'function') {
|
|
|
cachedClearTimeout = clearTimeout;
|
|
|
} else {
|
|
|
cachedClearTimeout = defaultClearTimeout;
|
|
|
}
|
|
|
} catch (e) {
|
|
|
cachedClearTimeout = defaultClearTimeout;
|
|
|
}
|
|
|
} ())
|
|
|
function runTimeout(fun) {
|
|
|
if (cachedSetTimeout === setTimeout) {
|
|
|
//normal enviroments in sane situations
|
|
|
return setTimeout(fun, 0);
|
|
|
}
|
|
|
// if setTimeout wasn't available but was latter defined
|
|
|
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
|
|
|
cachedSetTimeout = setTimeout;
|
|
|
return setTimeout(fun, 0);
|
|
|
}
|
|
|
try {
|
|
|
// when when somebody has screwed with setTimeout but no I.E. maddness
|
|
|
return cachedSetTimeout(fun, 0);
|
|
|
} catch(e){
|
|
|
try {
|
|
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
|
return cachedSetTimeout.call(null, fun, 0);
|
|
|
} catch(e){
|
|
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
|
|
|
return cachedSetTimeout.call(this, fun, 0);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
function runClearTimeout(marker) {
|
|
|
if (cachedClearTimeout === clearTimeout) {
|
|
|
//normal enviroments in sane situations
|
|
|
return clearTimeout(marker);
|
|
|
}
|
|
|
// if clearTimeout wasn't available but was latter defined
|
|
|
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
|
|
|
cachedClearTimeout = clearTimeout;
|
|
|
return clearTimeout(marker);
|
|
|
}
|
|
|
try {
|
|
|
// when when somebody has screwed with setTimeout but no I.E. maddness
|
|
|
return cachedClearTimeout(marker);
|
|
|
} catch (e){
|
|
|
try {
|
|
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
|
return cachedClearTimeout.call(null, marker);
|
|
|
} catch (e){
|
|
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
|
|
|
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
|
|
|
return cachedClearTimeout.call(this, marker);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
var queue = [];
|
|
|
var draining = false;
|
|
|
var currentQueue;
|
|
|
var queueIndex = -1;
|
|
|
|
|
|
function cleanUpNextTick() {
|
|
|
if (!draining || !currentQueue) {
|
|
|
return;
|
|
|
}
|
|
|
draining = false;
|
|
|
if (currentQueue.length) {
|
|
|
queue = currentQueue.concat(queue);
|
|
|
} else {
|
|
|
queueIndex = -1;
|
|
|
}
|
|
|
if (queue.length) {
|
|
|
drainQueue();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function drainQueue() {
|
|
|
if (draining) {
|
|
|
return;
|
|
|
}
|
|
|
var timeout = runTimeout(cleanUpNextTick);
|
|
|
draining = true;
|
|
|
|
|
|
var len = queue.length;
|
|
|
while(len) {
|
|
|
currentQueue = queue;
|
|
|
queue = [];
|
|
|
while (++queueIndex < len) {
|
|
|
if (currentQueue) {
|
|
|
currentQueue[queueIndex].run();
|
|
|
}
|
|
|
}
|
|
|
queueIndex = -1;
|
|
|
len = queue.length;
|
|
|
}
|
|
|
currentQueue = null;
|
|
|
draining = false;
|
|
|
runClearTimeout(timeout);
|
|
|
}
|
|
|
|
|
|
process.nextTick = function (fun) {
|
|
|
var args = new Array(arguments.length - 1);
|
|
|
if (arguments.length > 1) {
|
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
|
args[i - 1] = arguments[i];
|
|
|
}
|
|
|
}
|
|
|
queue.push(new Item(fun, args));
|
|
|
if (queue.length === 1 && !draining) {
|
|
|
runTimeout(drainQueue);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
// v8 likes predictible objects
|
|
|
function Item(fun, array) {
|
|
|
this.fun = fun;
|
|
|
this.array = array;
|
|
|
}
|
|
|
Item.prototype.run = function () {
|
|
|
this.fun.apply(null, this.array);
|
|
|
};
|
|
|
process.title = 'browser';
|
|
|
process.browser = true;
|
|
|
process.env = {};
|
|
|
process.argv = [];
|
|
|
process.version = ''; // empty string to avoid regexp issues
|
|
|
process.versions = {};
|
|
|
|
|
|
function noop() {}
|
|
|
|
|
|
process.on = noop;
|
|
|
process.addListener = noop;
|
|
|
process.once = noop;
|
|
|
process.off = noop;
|
|
|
process.removeListener = noop;
|
|
|
process.removeAllListeners = noop;
|
|
|
process.emit = noop;
|
|
|
process.prependListener = noop;
|
|
|
process.prependOnceListener = noop;
|
|
|
|
|
|
process.listeners = function (name) { return [] }
|
|
|
|
|
|
process.binding = function (name) {
|
|
|
throw new Error('process.binding is not supported');
|
|
|
};
|
|
|
|
|
|
process.cwd = function () { return '/' };
|
|
|
process.chdir = function (dir) {
|
|
|
throw new Error('process.chdir is not supported');
|
|
|
};
|
|
|
process.umask = function() { return 0; };
|
|
|
|
|
|
},{}],5:[function(require,module,exports){
|
|
|
(function (global){
|
|
|
/*! https://mths.be/punycode v1.4.1 by @mathias */
|
|
|
;(function(root) {
|
|
|
|
|
|
/** Detect free variables */
|
|
|
var freeExports = typeof exports == 'object' && exports &&
|
|
|
!exports.nodeType && exports;
|
|
|
var freeModule = typeof module == 'object' && module &&
|
|
|
!module.nodeType && module;
|
|
|
var freeGlobal = typeof global == 'object' && global;
|
|
|
if (
|
|
|
freeGlobal.global === freeGlobal ||
|
|
|
freeGlobal.window === freeGlobal ||
|
|
|
freeGlobal.self === freeGlobal
|
|
|
) {
|
|
|
root = freeGlobal;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* The `punycode` object.
|
|
|
* @name punycode
|
|
|
* @type Object
|
|
|
*/
|
|
|
var punycode,
|
|
|
|
|
|
/** Highest positive signed 32-bit float value */
|
|
|
maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
|
|
|
|
|
|
/** Bootstring parameters */
|
|
|
base = 36,
|
|
|
tMin = 1,
|
|
|
tMax = 26,
|
|
|
skew = 38,
|
|
|
damp = 700,
|
|
|
initialBias = 72,
|
|
|
initialN = 128, // 0x80
|
|
|
delimiter = '-', // '\x2D'
|
|
|
|
|
|
/** Regular expressions */
|
|
|
regexPunycode = /^xn--/,
|
|
|
regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
|
|
|
regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
|
|
|
|
|
|
/** Error messages */
|
|
|
errors = {
|
|
|
'overflow': 'Overflow: input needs wider integers to process',
|
|
|
'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
|
|
|
'invalid-input': 'Invalid input'
|
|
|
},
|
|
|
|
|
|
/** Convenience shortcuts */
|
|
|
baseMinusTMin = base - tMin,
|
|
|
floor = Math.floor,
|
|
|
stringFromCharCode = String.fromCharCode,
|
|
|
|
|
|
/** Temporary variable */
|
|
|
key;
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
|
|
/**
|
|
|
* A generic error utility function.
|
|
|
* @private
|
|
|
* @param {String} type The error type.
|
|
|
* @returns {Error} Throws a `RangeError` with the applicable error message.
|
|
|
*/
|
|
|
function error(type) {
|
|
|
throw new RangeError(errors[type]);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* A generic `Array#map` utility function.
|
|
|
* @private
|
|
|
* @param {Array} array The array to iterate over.
|
|
|
* @param {Function} callback The function that gets called for every array
|
|
|
* item.
|
|
|
* @returns {Array} A new array of values returned by the callback function.
|
|
|
*/
|
|
|
function map(array, fn) {
|
|
|
var length = array.length;
|
|
|
var result = [];
|
|
|
while (length--) {
|
|
|
result[length] = fn(array[length]);
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* A simple `Array#map`-like wrapper to work with domain name strings or email
|
|
|
* addresses.
|
|
|
* @private
|
|
|
* @param {String} domain The domain name or email address.
|
|
|
* @param {Function} callback The function that gets called for every
|
|
|
* character.
|
|
|
* @returns {Array} A new string of characters returned by the callback
|
|
|
* function.
|
|
|
*/
|
|
|
function mapDomain(string, fn) {
|
|
|
var parts = string.split('@');
|
|
|
var result = '';
|
|
|
if (parts.length > 1) {
|
|
|
// In email addresses, only the domain name should be punycoded. Leave
|
|
|
// the local part (i.e. everything up to `@`) intact.
|
|
|
result = parts[0] + '@';
|
|
|
string = parts[1];
|
|
|
}
|
|
|
// Avoid `split(regex)` for IE8 compatibility. See #17.
|
|
|
string = string.replace(regexSeparators, '\x2E');
|
|
|
var labels = string.split('.');
|
|
|
var encoded = map(labels, fn).join('.');
|
|
|
return result + encoded;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Creates an array containing the numeric code points of each Unicode
|
|
|
* character in the string. While JavaScript uses UCS-2 internally,
|
|
|
* this function will convert a pair of surrogate halves (each of which
|
|
|
* UCS-2 exposes as separate characters) into a single code point,
|
|
|
* matching UTF-16.
|
|
|
* @see `punycode.ucs2.encode`
|
|
|
* @see <https://mathiasbynens.be/notes/javascript-encoding>
|
|
|
* @memberOf punycode.ucs2
|
|
|
* @name decode
|
|
|
* @param {String} string The Unicode input string (UCS-2).
|
|
|
* @returns {Array} The new array of code points.
|
|
|
*/
|
|
|
function ucs2decode(string) {
|
|
|
var output = [],
|
|
|
counter = 0,
|
|
|
length = string.length,
|
|
|
value,
|
|
|
extra;
|
|
|
while (counter < length) {
|
|
|
value = string.charCodeAt(counter++);
|
|
|
if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
|
|
|
// high surrogate, and there is a next character
|
|
|
extra = string.charCodeAt(counter++);
|
|
|
if ((extra & 0xFC00) == 0xDC00) { // low surrogate
|
|
|
output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
|
|
|
} else {
|
|
|
// unmatched surrogate; only append this code unit, in case the next
|
|
|
// code unit is the high surrogate of a surrogate pair
|
|
|
output.push(value);
|
|
|
counter--;
|
|
|
}
|
|
|
} else {
|
|
|
output.push(value);
|
|
|
}
|
|
|
}
|
|
|
return output;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Creates a string based on an array of numeric code points.
|
|
|
* @see `punycode.ucs2.decode`
|
|
|
* @memberOf punycode.ucs2
|
|
|
* @name encode
|
|
|
* @param {Array} codePoints The array of numeric code points.
|
|
|
* @returns {String} The new Unicode string (UCS-2).
|
|
|
*/
|
|
|
function ucs2encode(array) {
|
|
|
return map(array, function(value) {
|
|
|
var output = '';
|
|
|
if (value > 0xFFFF) {
|
|
|
value -= 0x10000;
|
|
|
output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
|
|
|
value = 0xDC00 | value & 0x3FF;
|
|
|
}
|
|
|
output += stringFromCharCode(value);
|
|
|
return output;
|
|
|
}).join('');
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Converts a basic code point into a digit/integer.
|
|
|
* @see `digitToBasic()`
|
|
|
* @private
|
|
|
* @param {Number} codePoint The basic numeric code point value.
|
|
|
* @returns {Number} The numeric value of a basic code point (for use in
|
|
|
* representing integers) in the range `0` to `base - 1`, or `base` if
|
|
|
* the code point does not represent a value.
|
|
|
*/
|
|
|
function basicToDigit(codePoint) {
|
|
|
if (codePoint - 48 < 10) {
|
|
|
return codePoint - 22;
|
|
|
}
|
|
|
if (codePoint - 65 < 26) {
|
|
|
return codePoint - 65;
|
|
|
}
|
|
|
if (codePoint - 97 < 26) {
|
|
|
return codePoint - 97;
|
|
|
}
|
|
|
return base;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Converts a digit/integer into a basic code point.
|
|
|
* @see `basicToDigit()`
|
|
|
* @private
|
|
|
* @param {Number} digit The numeric value of a basic code point.
|
|
|
* @returns {Number} The basic code point whose value (when used for
|
|
|
* representing integers) is `digit`, which needs to be in the range
|
|
|
* `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
|
|
|
* used; else, the lowercase form is used. The behavior is undefined
|
|
|
* if `flag` is non-zero and `digit` has no uppercase form.
|
|
|
*/
|
|
|
function digitToBasic(digit, flag) {
|
|
|
// 0..25 map to ASCII a..z or A..Z
|
|
|
// 26..35 map to ASCII 0..9
|
|
|
return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Bias adaptation function as per section 3.4 of RFC 3492.
|
|
|
* https://tools.ietf.org/html/rfc3492#section-3.4
|
|
|
* @private
|
|
|
*/
|
|
|
function adapt(delta, numPoints, firstTime) {
|
|
|
var k = 0;
|
|
|
delta = firstTime ? floor(delta / damp) : delta >> 1;
|
|
|
delta += floor(delta / numPoints);
|
|
|
for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
|
|
|
delta = floor(delta / baseMinusTMin);
|
|
|
}
|
|
|
return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Converts a Punycode string of ASCII-only symbols to a string of Unicode
|
|
|
* symbols.
|
|
|
* @memberOf punycode
|
|
|
* @param {String} input The Punycode string of ASCII-only symbols.
|
|
|
* @returns {String} The resulting string of Unicode symbols.
|
|
|
*/
|
|
|
function decode(input) {
|
|
|
// Don't use UCS-2
|
|
|
var output = [],
|
|
|
inputLength = input.length,
|
|
|
out,
|
|
|
i = 0,
|
|
|
n = initialN,
|
|
|
bias = initialBias,
|
|
|
basic,
|
|
|
j,
|
|
|
index,
|
|
|
oldi,
|
|
|
w,
|
|
|
k,
|
|
|
digit,
|
|
|
t,
|
|
|
/** Cached calculation results */
|
|
|
baseMinusT;
|
|
|
|
|
|
// Handle the basic code points: let `basic` be the number of input code
|
|
|
// points before the last delimiter, or `0` if there is none, then copy
|
|
|
// the first basic code points to the output.
|
|
|
|
|
|
basic = input.lastIndexOf(delimiter);
|
|
|
if (basic < 0) {
|
|
|
basic = 0;
|
|
|
}
|
|
|
|
|
|
for (j = 0; j < basic; ++j) {
|
|
|
// if it's not a basic code point
|
|
|
if (input.charCodeAt(j) >= 0x80) {
|
|
|
error('not-basic');
|
|
|
}
|
|
|
output.push(input.charCodeAt(j));
|
|
|
}
|
|
|
|
|
|
// Main decoding loop: start just after the last delimiter if any basic code
|
|
|
// points were copied; start at the beginning otherwise.
|
|
|
|
|
|
for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
|
|
|
|
|
|
// `index` is the index of the next character to be consumed.
|
|
|
// Decode a generalized variable-length integer into `delta`,
|
|
|
// which gets added to `i`. The overflow checking is easier
|
|
|
// if we increase `i` as we go, then subtract off its starting
|
|
|
// value at the end to obtain `delta`.
|
|
|
for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
|
|
|
|
|
|
if (index >= inputLength) {
|
|
|
error('invalid-input');
|
|
|
}
|
|
|
|
|
|
digit = basicToDigit(input.charCodeAt(index++));
|
|
|
|
|
|
if (digit >= base || digit > floor((maxInt - i) / w)) {
|
|
|
error('overflow');
|
|
|
}
|
|
|
|
|
|
i += digit * w;
|
|
|
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
|
|
|
|
|
|
if (digit < t) {
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
baseMinusT = base - t;
|
|
|
if (w > floor(maxInt / baseMinusT)) {
|
|
|
error('overflow');
|
|
|
}
|
|
|
|
|
|
w *= baseMinusT;
|
|
|
|
|
|
}
|
|
|
|
|
|
out = output.length + 1;
|
|
|
bias = adapt(i - oldi, out, oldi == 0);
|
|
|
|
|
|
// `i` was supposed to wrap around from `out` to `0`,
|
|
|
// incrementing `n` each time, so we'll fix that now:
|
|
|
if (floor(i / out) > maxInt - n) {
|
|
|
error('overflow');
|
|
|
}
|
|
|
|
|
|
n += floor(i / out);
|
|
|
i %= out;
|
|
|
|
|
|
// Insert `n` at position `i` of the output
|
|
|
output.splice(i++, 0, n);
|
|
|
|
|
|
}
|
|
|
|
|
|
return ucs2encode(output);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Converts a string of Unicode symbols (e.g. a domain name label) to a
|
|
|
* Punycode string of ASCII-only symbols.
|
|
|
* @memberOf punycode
|
|
|
* @param {String} input The string of Unicode symbols.
|
|
|
* @returns {String} The resulting Punycode string of ASCII-only symbols.
|
|
|
*/
|
|
|
function encode(input) {
|
|
|
var n,
|
|
|
delta,
|
|
|
handledCPCount,
|
|
|
basicLength,
|
|
|
bias,
|
|
|
j,
|
|
|
m,
|
|
|
q,
|
|
|
k,
|
|
|
t,
|
|
|
currentValue,
|
|
|
output = [],
|
|
|
/** `inputLength` will hold the number of code points in `input`. */
|
|
|
inputLength,
|
|
|
/** Cached calculation results */
|
|
|
handledCPCountPlusOne,
|
|
|
baseMinusT,
|
|
|
qMinusT;
|
|
|
|
|
|
// Convert the input in UCS-2 to Unicode
|
|
|
input = ucs2decode(input);
|
|
|
|
|
|
// Cache the length
|
|
|
inputLength = input.length;
|
|
|
|
|
|
// Initialize the state
|
|
|
n = initialN;
|
|
|
delta = 0;
|
|
|
bias = initialBias;
|
|
|
|
|
|
// Handle the basic code points
|
|
|
for (j = 0; j < inputLength; ++j) {
|
|
|
currentValue = input[j];
|
|
|
if (currentValue < 0x80) {
|
|
|
output.push(stringFromCharCode(currentValue));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
handledCPCount = basicLength = output.length;
|
|
|
|
|
|
// `handledCPCount` is the number of code points that have been handled;
|
|
|
// `basicLength` is the number of basic code points.
|
|
|
|
|
|
// Finish the basic string - if it is not empty - with a delimiter
|
|
|
if (basicLength) {
|
|
|
output.push(delimiter);
|
|
|
}
|
|
|
|
|
|
// Main encoding loop:
|
|
|
while (handledCPCount < inputLength) {
|
|
|
|
|
|
// All non-basic code points < n have been handled already. Find the next
|
|
|
// larger one:
|
|
|
for (m = maxInt, j = 0; j < inputLength; ++j) {
|
|
|
currentValue = input[j];
|
|
|
if (currentValue >= n && currentValue < m) {
|
|
|
m = currentValue;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
|
|
|
// but guard against overflow
|
|
|
handledCPCountPlusOne = handledCPCount + 1;
|
|
|
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
|
|
|
error('overflow');
|
|
|
}
|
|
|
|
|
|
delta += (m - n) * handledCPCountPlusOne;
|
|
|
n = m;
|
|
|
|
|
|
for (j = 0; j < inputLength; ++j) {
|
|
|
currentValue = input[j];
|
|
|
|
|
|
if (currentValue < n && ++delta > maxInt) {
|
|
|
error('overflow');
|
|
|
}
|
|
|
|
|
|
if (currentValue == n) {
|
|
|
// Represent delta as a generalized variable-length integer
|
|
|
for (q = delta, k = base; /* no condition */; k += base) {
|
|
|
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
|
|
|
if (q < t) {
|
|
|
break;
|
|
|
}
|
|
|
qMinusT = q - t;
|
|
|
baseMinusT = base - t;
|
|
|
output.push(
|
|
|
stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
|
|
|
);
|
|
|
q = floor(qMinusT / baseMinusT);
|
|
|
}
|
|
|
|
|
|
output.push(stringFromCharCode(digitToBasic(q, 0)));
|
|
|
bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
|
|
|
delta = 0;
|
|
|
++handledCPCount;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
++delta;
|
|
|
++n;
|
|
|
|
|
|
}
|
|
|
return output.join('');
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Converts a Punycode string representing a domain name or an email address
|
|
|
* to Unicode. Only the Punycoded parts of the input will be converted, i.e.
|
|
|
* it doesn't matter if you call it on a string that has already been
|
|
|
* converted to Unicode.
|
|
|
* @memberOf punycode
|
|
|
* @param {String} input The Punycoded domain name or email address to
|
|
|
* convert to Unicode.
|
|
|
* @returns {String} The Unicode representation of the given Punycode
|
|
|
* string.
|
|
|
*/
|
|
|
function toUnicode(input) {
|
|
|
return mapDomain(input, function(string) {
|
|
|
return regexPunycode.test(string)
|
|
|
? decode(string.slice(4).toLowerCase())
|
|
|
: string;
|
|
|
});
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Converts a Unicode string representing a domain name or an email address to
|
|
|
* Punycode. Only the non-ASCII parts of the domain name will be converted,
|
|
|
* i.e. it doesn't matter if you call it with a domain that's already in
|
|
|
* ASCII.
|
|
|
* @memberOf punycode
|
|
|
* @param {String} input The domain name or email address to convert, as a
|
|
|
* Unicode string.
|
|
|
* @returns {String} The Punycode representation of the given domain name or
|
|
|
* email address.
|
|
|
*/
|
|
|
function toASCII(input) {
|
|
|
return mapDomain(input, function(string) {
|
|
|
return regexNonASCII.test(string)
|
|
|
? 'xn--' + encode(string)
|
|
|
: string;
|
|
|
});
|
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
|
|
/** Define the public API */
|
|
|
punycode = {
|
|
|
/**
|
|
|
* A string representing the current Punycode.js version number.
|
|
|
* @memberOf punycode
|
|
|
* @type String
|
|
|
*/
|
|
|
'version': '1.4.1',
|
|
|
/**
|
|
|
* An object of methods to convert from JavaScript's internal character
|
|
|
* representation (UCS-2) to Unicode code points, and back.
|
|
|
* @see <https://mathiasbynens.be/notes/javascript-encoding>
|
|
|
* @memberOf punycode
|
|
|
* @type Object
|
|
|
*/
|
|
|
'ucs2': {
|
|
|
'decode': ucs2decode,
|
|
|
'encode': ucs2encode
|
|
|
},
|
|
|
'decode': decode,
|
|
|
'encode': encode,
|
|
|
'toASCII': toASCII,
|
|
|
'toUnicode': toUnicode
|
|
|
};
|
|
|
|
|
|
/** Expose `punycode` */
|
|
|
// Some AMD build optimizers, like r.js, check for specific condition patterns
|
|
|
// like the following:
|
|
|
if (
|
|
|
typeof define == 'function' &&
|
|
|
typeof define.amd == 'object' &&
|
|
|
define.amd
|
|
|
) {
|
|
|
define('punycode', function() {
|
|
|
return punycode;
|
|
|
});
|
|
|
} else if (freeExports && freeModule) {
|
|
|
if (module.exports == freeExports) {
|
|
|
// in Node.js, io.js, or RingoJS v0.8.0+
|
|
|
freeModule.exports = punycode;
|
|
|
} else {
|
|
|
// in Narwhal or RingoJS v0.7.0-
|
|
|
for (key in punycode) {
|
|
|
punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
// in Rhino or a web browser
|
|
|
root.punycode = punycode;
|
|
|
}
|
|
|
|
|
|
}(this));
|
|
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
|
},{}],6:[function(require,module,exports){
|
|
|
(function (Buffer){
|
|
|
var sha3 = require('js-sha3').keccak_256
|
|
|
var uts46 = require('idna-uts46')
|
|
|
|
|
|
function namehash (inputName) {
|
|
|
// Reject empty names:
|
|
|
var node = ''
|
|
|
for (var i = 0; i < 32; i++) {
|
|
|
node += '00'
|
|
|
}
|
|
|
|
|
|
name = normalize(inputName)
|
|
|
|
|
|
if (name) {
|
|
|
var labels = name.split('.')
|
|
|
|
|
|
for(var i = labels.length - 1; i >= 0; i--) {
|
|
|
var labelSha = sha3(labels[i])
|
|
|
node = sha3(new Buffer(node + labelSha, 'hex'))
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return `0x${node}`
|
|
|
}
|
|
|
|
|
|
function normalize(name) {
|
|
|
return name ? uts46.toUnicode(name, {useStd3ASCII: true, transitional: false}) : name
|
|
|
}
|
|
|
|
|
|
exports.hash = namehash
|
|
|
exports.normalize = normalize
|
|
|
|
|
|
}).call(this,require("buffer").Buffer)
|
|
|
},{"buffer":2,"idna-uts46":8,"js-sha3":9}],7:[function(require,module,exports){
|
|
|
/* This file is generated from the Unicode IDNA table, using
|
|
|
the build-unicode-tables.py script. Please edit that
|
|
|
script instead of this file. */
|
|
|
|
|
|
/* istanbul ignore next */
|
|
|
(function (root, factory) {
|
|
|
if (typeof define === 'function' && define.amd) {
|
|
|
define([], function () { return factory(); });
|
|
|
} else if (typeof exports === 'object') {
|
|
|
module.exports = factory();
|
|
|
} else {
|
|
|
root.uts46_map = factory();
|
|
|
}
|
|
|
}(this, function () {
|
|
|
var blocks = [
|
|
|
new Uint32Array([2157250,2157314,2157378,2157442,2157506,2157570,2157634,0,2157698,2157762,2157826,2157890,2157954,0,2158018,0]),
|
|
|
new Uint32Array([2100833,2100897,0,0,2101569,2101697,2101825,2101953,2102081,2102209,10575585,2187009,10502177,10489601,10489697,2112289]),
|
|
|
new Uint32Array([2179041,6291456,2179073,6291456,2179105,6291456,2179137,6291456,2179169,6291456,2179201,6291456,2179233,6291456,2179265,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,14680064,14680064,14680064,14680064,14680064]),
|
|
|
new Uint32Array([6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,23068672,23068672,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,0,0,0,0,23068672,23068672,23068672,0,0,0,0,23068672]),
|
|
|
new Uint32Array([14680064,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,14680064,14680064]),
|
|
|
new Uint32Array([2193057,2193089,2193121,2193153,2117665,2117569,2193185,2193217,2193249,2193281,2193313,2193345,2193377,2193409,2193441,2193473]),
|
|
|
new Uint32Array([2212481,2212513,2212545,2212577,2197089,2212609,2212641,2212673,2212705,2212737,2212769,2212801,2212833,2212865,2212897,2212929]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,6291456,0,0,0,0,0]),
|
|
|
new Uint32Array([2097281,2105921,2097729,2106081,0,2097601,2162337,2106017,2133281,2097505,2105889,2097185,2097697,2135777,2097633,2097441]),
|
|
|
new Uint32Array([2177025,6291456,2177057,6291456,2177089,6291456,2177121,6291456,2177153,6291456,2177185,6291456,2177217,6291456,2177249,6291456]),
|
|
|
new Uint32Array([2233665,2233697,2233729,2233761,2233793,2233825,2233825,2217537,2233857,2233889,2233921,2233953,2215649,2233985,2234017,2234049]),
|
|
|
new Uint32Array([0,0,0,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,0,6291456,6291456,0,0,0,0,0,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,6291456]),
|
|
|
new Uint32Array([0,23068672,23068672,23068672,0,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,6291456]),
|
|
|
new Uint32Array([2184705,6291456,2184737,6291456,2184769,6291456,2184801,6291456,2184833,6291456,2184865,6291456,2184897,6291456,2184929,6291456]),
|
|
|
new Uint32Array([2215425,2215457,2215489,2215521,2215553,2215585,2215617,2215649,2215681,2215713,2215745,2215777,2192001,2215809,2215841,2215873]),
|
|
|
new Uint32Array([0,0,0,0,0,0,0,6291456,2168673,2169249,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2128195,2128291,2128387,2128483,2128579,2128675,2128771,2128867,2128963,2129059,2129155,2129251,2129347,2129443,2129539,2129635]),
|
|
|
new Uint32Array([2147906,2147970,2148034,2148098,2148162,2148226,2148290,2148354,2147906,2147970,2148034,2148098,2148162,2148226,2148290,2148354]),
|
|
|
new Uint32Array([6291456,2186945,6291456,6291456,6291456,6291456,6291456,10537858,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2125219,2125315,2152834,2152898,2125411,2152962,2153026,2125506,2125507,2125603,2153090,2153154,2153218,2153282,2153346,2105348]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,6291456,0,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,23068672,6291456,2145538,23068672,23068672,23068672,23068672,23068672,23068672,23068672,0,0,0,0,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,6291456,23068672,23068672,6291456]),
|
|
|
new Uint32Array([2119939,2124930,2125026,2106658,2125218,2128962,2129058,2129154,2129250,2129346,2129442,2108866,2108770,2150466,2150530,2150594]),
|
|
|
new Uint32Array([2201601,6291456,2201633,6291456,2201665,6291456,2201697,6291456,2201729,6291456,2201761,6291456,2201793,6291456,2201825,6291456]),
|
|
|
new Uint32Array([2202497,6291456,2202529,6291456,2202561,6291456,2202593,6291456,2202625,6291456,2202657,6291456,2202689,6291456,2202721,6291456]),
|
|
|
new Uint32Array([6291456,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([0,6291456,6291456,0,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2190529,6291456,2190561,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2190593,6291456,2190625,6291456,23068672]),
|
|
|
new Uint32Array([2097185,2097697,2097697,2097697,2097697,2135777,2135777,2135777,2135777,2097377,2097377,2097377,2097377,2097601,2097601,2097217]),
|
|
|
new Uint32Array([2232353,2232385,2232418,2232481,2232513,2231201,2232546,2232609,2232641,2232673,2232705,2217281,2232738,2191201,2232801,2232833]),
|
|
|
new Uint32Array([23068672,18884130,23068672,23068672,23068672,6291456,23068672,23068672,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672]),
|
|
|
new Uint32Array([6291456,6291456,23068672,23068672,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([0,0,2148994,2149058,2149122,0,6291456,2149186,2186913,2173537,2148993,2149121,2149058,10531458,10496066,0]),
|
|
|
new Uint32Array([2098209,2111137,2105505,2098241,2108353,2108417,2105825,2111713,2100897,2111905,2105473,2105569,2105601,2112289,2108193,2112481]),
|
|
|
new Uint32Array([2132227,2132323,2132419,2132419,2132515,2132515,2132611,2132707,2132707,2132803,2132899,2132899,2132995,2132995,2133091,2133187]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2185921,2185953,2185985,2186017,2186049,2186081,2186113,2186145]),
|
|
|
new Uint32Array([23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,6291456,0,0]),
|
|
|
new Uint32Array([2112481,2112577,2098177,2098305,2108321,2108289,2100865,2113153,2108481,2113345,2113441,10609889,10610785,10609921,10610817,2222241]),
|
|
|
new Uint32Array([6291456,6291456,6291456,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,0,0]),
|
|
|
new Uint32Array([2232865,2232897,2231745,2232929,2232961,2217441,2215521,2215553,2217473,2232993,2233025,2209697,2233057,2215585,2233089,2233121]),
|
|
|
new Uint32Array([2191649,2191681,2191713,2191745,2153281,2191777,2191809,2191841,2191873,2191905,2191937,2191969,2192001,2192033,2192065,2192097]),
|
|
|
new Uint32Array([0,0,0,0,6291456,6291456,6291456,6291456,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2197857,2197889,2197921,2197953,2197985,2198017,2198049,2198081,2198113,2198145,2198177,2198209,2198241,2198273,2198305,2198337]),
|
|
|
new Uint32Array([6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,0,0,23068672,23068672,0,0,23068672,23068672,23068672,6291456,0]),
|
|
|
new Uint32Array([2192641,2192673,2192705,2192737,2192769,2192801,2192833,2118049,2192865,2117473,2117761,2192897,2192929,2192961,2192993,2193025]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2147905,2147969,2148033,2148097,2148161,2148225,2148289,2148353]),
|
|
|
new Uint32Array([2173921,2173953,2173985,2173761,2174017,2174049,2174081,2174113,2174145,2174177,2149057,2230753,2148481,2173601,2173633,2173665]),
|
|
|
new Uint32Array([2203777,6291456,2203809,6291456,2203841,6291456,2203873,6291456,2203905,6291456,2173121,2180961,2181217,2203937,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,23068672,23068672]),
|
|
|
new Uint32Array([0,23068672,23068672,23068672,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,6291456]),
|
|
|
new Uint32Array([2180353,2180385,2144033,2180417,2180449,2180481,2180513,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2112481,2112577,2098177,2098305,2108321,2108289,2100865,2113153,2108481,2113345,2113441,10610209,10610465,10610241,10610753,10609857]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,0,0]),
|
|
|
new Uint32Array([2223842,2223906,2223970,2224034,2224098,2224162,2224226,2224290,2224354,2224418,2224482,2224546,2224610,2224674,2224738,2224802]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,6291456,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456]),
|
|
|
new Uint32Array([2192129,2192161,2192193,2192225,2192257,2192289,2192321,2192353,2192385,2192417,2192449,2192481,2192513,2192545,2192577,2192609]),
|
|
|
new Uint32Array([23068672,23068672,23068672,18923650,23068672,23068672,23068672,23068672,0,23068672,23068672,23068672,23068672,18923714,23068672,23068672]),
|
|
|
new Uint32Array([2126179,2125538,2126275,2126371,2126467,2125634,2126563,2105603,2105604,2125346,2126659,2126755,2126851,2098179,2098181,2098182]),
|
|
|
new Uint32Array([6291456,2170881,2170913,2170945,6291456,2170977,6291456,2171009,2171041,6291456,6291456,6291456,2171073,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([2132226,2132514,2163586,2132610,2160386,2133090,2133186,2160450,2160514,2160578,2133570,2106178,2160642,2133858,2160706,2160770]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([0,0,0,0,0,0,0,0,0,0,0,0,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,23068672]),
|
|
|
new Uint32Array([2098209,2108353,2108193,2108481,2170241,2111713,2105473,2105569,2105601,2112289,2112481,2098305,2108321,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,2186593,0,0,6291456,6291456,2186625,2186657,2186689,2173505,0,10496067,10496163,10496259]),
|
|
|
new Uint32Array([2240130,2240194,2240257,2240289,2218305,2240321,2240353,2240385,2240417,2240449,2240481,2240514,2240577,2240610,2240673,0]),
|
|
|
new Uint32Array([2246465,2246497,2246529,2246561,2194977,2246594,2246657,2246689,2246721,2246753,2246785,2246818,2246882,2246945,2246977,2247009]),
|
|
|
new Uint32Array([2215105,6291456,2215137,6291456,6291456,2215169,2215201,6291456,6291456,6291456,2215233,2215265,2215297,2215329,2215361,2215393]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,0,0,6291456,0,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,6291456,6291456,6291456,23068672,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([10505091,10505187,10505283,10505379,10505475,10505571,10505667,10505763,10505859,10505955,10506051,10506147,10506243,10506339,10506435,10506531]),
|
|
|
new Uint32Array([2105505,2098241,2108353,2108417,2105825,0,2100897,2111905,2105473,2105569,2105601,2112289,2108193,2112481,2112577,2098177]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,10502115,10502178,10502211,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([0,23068672,23068672,23068672,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,6291456]),
|
|
|
new Uint32Array([2192321,2236130,2236130,2236193,2236225,2236225,2236257,2236290,2236354,2236417,2236449,2236481,2236513,2236545,2236577,2236609]),
|
|
|
new Uint32Array([2173793,2173985,2174017,6291456,2173761,2173697,6291456,2174689,6291456,2174017,2174721,6291456,6291456,2174753,2174785,2174817]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([10485857,6291456,2197185,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2132898,2163842,2163906,2133282,2132034,2131938,2137410,2132802,2132706,2164866,2133282,2160578,2165186,2165186,6291456,6291456]),
|
|
|
new Uint32Array([2100833,2100737,2098337,2101441,2101569,2101697,2101825,2101953,2102081,2102209,10575585,2187009,10502177,10489601,10489697,0]),
|
|
|
new Uint32Array([10500003,10500099,10500195,10500291,10500387,10500483,10500579,10500675,10500771,10500867,10500963,10501059,10501155,10501251,10501347,10501443]),
|
|
|
new Uint32Array([2163458,2130978,2131074,2131266,2131362,2163522,2160130,2132066,2131010,2131106,2106018,2131618,2131298,2132034,2131938,2137410]),
|
|
|
new Uint32Array([2212961,2116993,2212993,2213025,2213057,2213089,2213121,2213153,2213185,2213217,2213249,2209633,2213281,2213313,2213345,2213377]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,23068672,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,6291456]),
|
|
|
new Uint32Array([2167105,2167137,2167169,2167201,2167233,2167265,2167297,2167329,2167361,2167393,2167425,2167457,2167489,2167521,2167553,2167585]),
|
|
|
new Uint32Array([2174081,2174113,2174145,2174177,2149057,2230753,2148481,2173601,2173633,2173665,2173697,2173729,2148801,2173761,2143969,2173793]),
|
|
|
new Uint32Array([2108289,2100865,2113153,2108481,2113345,2113441,2098209,2111137,2105505,2098241,2108353,2108417,2105825,2111713,2100897,2111905]),
|
|
|
new Uint32Array([6291456,6291456,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,0,0]),
|
|
|
new Uint32Array([6291456,0,6291456,2145026,0,6291456,2145090,0,6291456,6291456,0,0,23068672,0,23068672,23068672]),
|
|
|
new Uint32Array([6291456,6291456,6291456,0,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,23068672,6291456,0,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,23068672,23068672,0,0,23068672,23068672,23068672,23068672,23068672,23068672,23068672,0,0,0]),
|
|
|
new Uint32Array([0,10554498,10554562,10554626,10554690,10554754,10554818,10554882,10554946,10555010,10555074,6291456,6291456,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,2172833,6291456,2172865,2172897,2172929,2172961,6291456,2172993,6291456,2173025,6291456,2173057,6291456,2173089,6291456]),
|
|
|
new Uint32Array([2245986,2246050,2246113,2246145,2208321,2246177,2246209,2246241,2246273,2246305,2246337,2218945,2246369,2246401,2246433,0]),
|
|
|
new Uint32Array([6291456,0,6291456,6291456,0,6291456,6291456,6291456,6291456,6291456,0,0,23068672,6291456,23068672,23068672]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,6291456,6291456,6291456,2190721]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456,23068672,6291456,6291456]),
|
|
|
new Uint32Array([2168321,6291456,2168353,6291456,2168385,6291456,2168417,6291456,2168449,6291456,2168481,6291456,2168513,6291456,2168545,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([6291456,0,6291456,6291456,6291456,6291456,0,0,0,6291456,6291456,0,6291456,0,6291456,6291456]),
|
|
|
new Uint32Array([2139426,2160834,2160898,2160962,2134242,2161026,2161090,2161154,2161218,2161282,2161346,2161410,2138658,2161474,2161538,2134722]),
|
|
|
new Uint32Array([2178785,6291456,2178817,6291456,2178849,6291456,2178881,6291456,2178913,6291456,2178945,6291456,2178977,6291456,2179009,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,6291456]),
|
|
|
new Uint32Array([6291456,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2098209,2167297,2111137,6291456]),
|
|
|
new Uint32Array([2171393,6291456,2171425,6291456,2171457,6291456,2171489,6291456,2171521,6291456,2171553,6291456,2171585,6291456,2171617,6291456]),
|
|
|
new Uint32Array([2098305,2108321,2108289,2100865,2113153,2108481,2113345,2113441,2098209,2111137,2105505,2098241,2108353,2108417,2105825,2111713]),
|
|
|
new Uint32Array([0,0,0,0,0,0,0,23068672,0,0,0,0,2144834,2144898,0,2144962]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,0,0,23068672]),
|
|
|
new Uint32Array([2108193,2112481,2112577,2098177,2098305,2108321,2108289,2100865,2113153,2108481,2113345,2113441,2098209,0,2105505,2098241]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,0,6291456,6291456,6291456,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,2202049,6291456,2202081,6291456,2202113,6291456,2202145,6291456,2202177,6291456,2202209,6291456,2202241,6291456]),
|
|
|
new Uint32Array([10501155,10501251,10501347,10501443,10501539,10501635,10501731,10501827,10501923,10502019,2141731,2105505,2098177,2155586,2166530,0]),
|
|
|
new Uint32Array([10610305,10610337,10575585,2221761,10610401,10610433,10502177,0,10610465,10610497,10610529,10610561,0,0,0,0]),
|
|
|
new Uint32Array([2102081,2102209,2100833,2100737,2098337,2101441,2101569,2101697,2101825,2101953,2102081,2102209,2100833,2100737,2098337,2101441]),
|
|
|
new Uint32Array([2146882,2146946,2147010,2147074,2147138,2147202,2147266,2147330,2146882,2146946,2147010,2147074,2147138,2147202,2147266,2147330]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0]),
|
|
|
new Uint32Array([10502307,10502403,10502499,10502595,10502691,10502787,10502883,10502979,10503075,10503171,10503267,10503363,10503459,10503555,10503651,10503747]),
|
|
|
new Uint32Array([2179937,2179969,2180001,2180033,2156545,2180065,2156577,2180097,2180129,2180161,2180193,2180225,2180257,2180289,2156737,2180321]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,6291456,0,0,0,6291456,0,0,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2165764,2140004]),
|
|
|
new Uint32Array([2177281,6291456,2177313,6291456,2177345,6291456,2177377,6291456,2177409,6291456,2177441,6291456,2177473,6291456,2177505,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2180641,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2105601,2112289,2108193,2112481,2112577,0,2098305,2108321,2108289,2100865,2113153,2108481,2113345,0,2098209,2111137]),
|
|
|
new Uint32Array([0,6291456,6291456,6291456,0,6291456,0,6291456,0,0,6291456,6291456,0,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456]),
|
|
|
new Uint32Array([2221985,2165601,2165601,2165665,2165665,2222017,2222017,2165729,2165729,2158913,2158913,2158913,2158913,2097281,2097281,2105921]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,0,23068672,23068672,23068672,0,23068672,23068672,23068672,23068672,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2149634,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2176897,6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,2176929,6291456,2176961,6291456,2176993,6291456]),
|
|
|
new Uint32Array([2172641,6291456,2172673,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2172705,2172737,6291456,2172769,2172801,6291456]),
|
|
|
new Uint32Array([2099173,2104196,2121667,2099395,2121763,2152258,2152322,2098946,2152386,2121859,2121955,2099333,2122051,2104324,2099493,2122147]),
|
|
|
new Uint32Array([2187041,6291456,6291456,6291456,6291456,2098241,2098241,2108353,2100897,2111905,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,2145794,6291456,6291456,6291456,6291456,0,6291456,6291456,6291456,6291456,2145858,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,0,0,6291456,0]),
|
|
|
new Uint32Array([0,2105921,2097729,0,2097377,0,0,2106017,0,2097505,2105889,2097185,2097697,2135777,2097633,2097441]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([14680064,2098209,2111137,2105505,2098241,2108353,2108417,2105825,2111713,2100897,2111905,2105473,2105569,2105601,2112289,2108193]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,0,6291456,23068672]),
|
|
|
new Uint32Array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23068672]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2146114,6291456,6291456,6291456,0,0,0]),
|
|
|
new Uint32Array([2105921,2105921,2105921,2222049,2222049,2130977,2130977,2130977,2130977,2160065,2160065,2160065,2160065,2097729,2097729,2097729]),
|
|
|
new Uint32Array([2194529,2194561,2194593,2119777,2119873,2194625,2194657,2194689,2194721,2194753,2194785,2194817,2194849,2194881,2194913,2194945]),
|
|
|
new Uint32Array([0,0,0,2156546,2156610,2156674,2156738,2156802,0,0,0,0,0,2156866,23068672,2156930]),
|
|
|
new Uint32Array([23068672,23068672,23068672,0,0,0,0,23068672,23068672,0,0,23068672,23068672,23068672,0,0]),
|
|
|
new Uint32Array([2214369,2214401,2214433,2214465,2214497,2214529,2214561,2214593,2194945,2214625,2195041,2214657,2214689,2214721,6291456,6291456]),
|
|
|
new Uint32Array([2183585,6291456,2183617,6291456,2183649,6291456,2183681,6291456,2183713,6291456,2183745,6291456,2183777,6291456,2183809,6291456]),
|
|
|
new Uint32Array([2105601,2169121,2108193,2170049,2180993,2181025,2112481,2108321,2108289,2181057,2170497,2100865,2181089,2173601,2173633,2173665]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,0,0,2185729,2185761,2185793,2185825,2185857,2185889,0,0]),
|
|
|
new Uint32Array([0,10537921,10610689,10610273,10610497,10610529,10610305,10610721,10489601,10489697,10610337,10575585,10554529,2221761,2197185,10496577]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2201857,6291456,2201889,6291456,2201921,6291456,2201953,6291456,2201985,6291456,2202017,6291456,2176193,2176257,23068672,23068672]),
|
|
|
new Uint32Array([6291456,6291456,23068672,23068672,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([10554529,2221089,0,10502113,10562017,10537921,10538049,2221121,2221153,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2181569,2170561,2181601,2181633,2170753,2181665,2172897,2170881,2181697,2170913,2172929,2113441,2181729,2181761,2171009,2173761]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,6291456,23068672,23068672,23068672,6291456,23068672,23068672,23068672,23068672,23068672,0,0]),
|
|
|
new Uint32Array([2166978,2167042,2099169,0,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2180545,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2231265,2231297,2193601,2231329,2231361,2231393,2231425,2231457,2231489,2116513,2116705,2231521,2200481,2199873,2200513,2231553]),
|
|
|
new Uint32Array([10518915,10519011,10519107,10519203,2162242,2162306,2159554,2162370,2159362,2159618,2105922,2162434,2159746,2162498,2159810,2159874]),
|
|
|
new Uint32Array([2187649,2187681,2187713,2187745,2187777,2187809,2187841,2187873,2187905,2187937,2187969,2188001,2188033,2188065,2188097,2188129]),
|
|
|
new Uint32Array([2161730,2161794,2135586,2161858,2161922,2137186,2131810,2160290,2135170,2161986,2137954,2162050,2162114,2162178,10518723,10518819]),
|
|
|
new Uint32Array([2235073,2235106,2235169,2235201,0,2191937,2235233,2235265,2192001,2235297,2235329,2235362,2235425,2235458,2235521,2235553]),
|
|
|
new Uint32Array([10506627,10506723,10506819,10506915,10507011,10507107,10507203,10507299,10507395,10507491,10507587,10507683,10507779,10507875,10507971,10508067]),
|
|
|
new Uint32Array([2187105,2221473,2221505,2221537,2221569,6291456,6291456,10610209,10610241,10537986,10537986,10537986,10537986,10609857,10609857,10609857]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,0]),
|
|
|
new Uint32Array([2175873,2175905,2175937,2175969,2176001,2176033,2176065,2176097,2176129,2176161,2176193,2176225,2176257,2176289,2176321,2176353]),
|
|
|
new Uint32Array([2140006,2140198,2140390,2140582,2140774,23068672,23068672,23068672,23068672,23068672,6291456,6291456,6291456,23068672,23068672,23068672]),
|
|
|
new Uint32Array([2215905,2207041,2153185,2237057,2237089,2237121,2237153,2237185,2237218,2237281,2237313,2237345,2237377,2237409,2237442,2237505]),
|
|
|
new Uint32Array([2108193,2112481,2112577,2098177,2098305,2108321,2108289,2100865,2113153,2108481,2113345,2113441,2098209,2111137,2105505,2098241]),
|
|
|
new Uint32Array([0,23068672,0,0,0,0,0,0,0,2145154,2145218,2145282,6291456,0,2145346,0]),
|
|
|
new Uint32Array([0,0,0,0,10531458,10495395,2148545,2143201,2173473,2148865,2173505,0,2173537,0,2173569,2149121]),
|
|
|
new Uint32Array([6291456,6291456,6291456,0,0,0,0,0,0,0,0,0,0,0,0,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,23068672,23068672,23068672,6291456,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([10554529,2221089,0,0,10562017,10502113,10538049,10537921,2221185,10489601,10489697,10609889,10609921,2141729,2141793,10610273]),
|
|
|
new Uint32Array([2141923,2142019,2142115,2142211,2142307,2142403,2142499,2142595,2142691,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,0]),
|
|
|
new Uint32Array([2099233,2122017,2200641,2098113,2121537,2103201,2200673,2104033,2121857,2121953,2122401,2099649,2099969,2123009,2100129,2100289]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,18923970,23068672,23068672,23068672,0,6291456,6291456]),
|
|
|
new Uint32Array([2189761,6291456,2189793,6291456,2189825,6291456,2189857,6291456,2189889,6291456,2189921,6291456,2189953,6291456,2189985,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,0,0,0,0,0,0,0,0,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([18884449,18884065,23068672,18884417,18884034,18921185,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,18874368]),
|
|
|
new Uint32Array([2101569,2101697,2101825,2101953,2102081,2102209,2100833,2100737,2098337,2101441,2101569,2101697,2101825,2101953,2102081,2102209]),
|
|
|
new Uint32Array([2101922,2102050,2102178,2102306,10498755,10498851,10498947,10499043,10499139,10499235,10499331,10499427,10499523,10489604,10489732,10489860]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,0,0,0,0,0]),
|
|
|
new Uint32Array([0,2105921,2097729,2106081,0,2097601,2162337,2106017,2133281,2097505,0,2097185,2097697,2135777,2097633,2097441]),
|
|
|
new Uint32Array([2218625,2241890,2241954,2242018,2242082,2242145,2242177,2242177,2218657,2219681,2242209,2242241,2242273,2242306,2242369,2208481]),
|
|
|
new Uint32Array([6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,0,0,0,0,0,0,0,6291456,6291456,6291456,6291456,0,0,0]),
|
|
|
new Uint32Array([2169729,6291456,2169761,6291456,2169793,6291456,2169825,6291456,2169857,2169889,6291456,2169921,6291456,2143329,6291456,2098305]),
|
|
|
new Uint32Array([2162178,2163202,2163266,2135170,2136226,2161986,2137954,2159426,2159490,2163330,2159554,2163394,2159682,2139522,2136450,2159746]),
|
|
|
new Uint32Array([2173953,2173985,0,2174017,2174049,2174081,2174113,2174145,2174177,2149057,2174209,2174241,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2213409,2213441,2213473,2213505,2213537,2213569,2213601,2213633,2213665,2195649,2213697,2213729,2213761,2213793,2213825,2213857]),
|
|
|
new Uint32Array([2183073,6291456,2183105,6291456,2183137,6291456,2183169,6291456,2183201,6291456,2183233,6291456,2183265,6291456,2183297,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([0,0,0,0,0,0,0,23068672,0,0,0,0,0,0,0,6291456]),
|
|
|
new Uint32Array([6291456,6291456,0,0,0,0,0,0,0,6291456,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2171873,6291456,2171905,6291456,2171937,6291456,2171969,6291456,2172001,6291456,2172033,6291456,2172065,6291456,2172097,6291456]),
|
|
|
new Uint32Array([10575489,2098209,2111137,2105505,2098241,2108353,2108417,2105825,2111713,2100897,2111905,2105473,2105569,2105601,2112289,2108193]),
|
|
|
new Uint32Array([2172129,6291456,2172161,6291456,2172193,6291456,2172225,6291456,2172257,6291456,2172289,6291456,2172321,6291456,2172353,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,6291456,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2231873,2231905,2231937,2231970,2232033,2215425,2232065,2232097,2232129,2232161,2215457,2232193,2232225,2232258,2215489,2232321]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,14680064,14680064,14680064,14680064,14680064,14680064]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,23068672,0,0,0,0,23068672]),
|
|
|
new Uint32Array([2217249,2217281,2217313,2217345,2217377,2217409,2217441,2217473,2215617,2217505,2217537,2217569,2214753,2217601,2217633,2217665]),
|
|
|
new Uint32Array([2170273,2170305,6291456,2170337,2170369,6291456,2170401,2170433,2170465,6291456,6291456,6291456,2170497,2170529,6291456,2170561]),
|
|
|
new Uint32Array([2188641,6291456,2188673,2188705,2188737,6291456,6291456,2188769,6291456,2188801,6291456,2188833,6291456,2180897,2181473,2180865]),
|
|
|
new Uint32Array([10489988,10490116,10490244,10490372,10490500,10490628,10490756,10490884,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2147393,2147457,2147521,2147585,2147649,2147713,2147777,2147841]),
|
|
|
new Uint32Array([2244833,2244865,2244897,2244929,2244961,2244993,2245025,2245058,2210209,2245121,2245153,2245185,2245217,2245249,2245281,2216769]),
|
|
|
new Uint32Array([2185473,6291456,2185505,6291456,2185537,6291456,2185569,6291456,2185601,6291456,2185633,6291456,2185665,6291456,2185697,6291456]),
|
|
|
new Uint32Array([23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2220417,2220417,2220449,2220449,2220481,2220481,2220513,2220513,2220545,2220545,2220577,2220577,2220609,2220609,2220641,2220641]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,2144002,0,6291456,6291456,0,0,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2198849,2198881,2198913,2198945,2198977,2199009,2199041,2199073,2199105,2199137,2199169,2199201,2199233,2199265,2199297,2199329]),
|
|
|
new Uint32Array([2173825,2153473,2173857,2173889,2173921,2173953,2173985,2173761,2174017,2174049,2174081,2174113,2174145,2174177,2149057,2230753]),
|
|
|
new Uint32Array([0,0,0,0,0,0,0,2180577,0,0,0,0,0,2180609,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672,0,0,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([10508163,10508259,10508355,10508451,2200097,2200129,2192705,2200161,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2116513,2190785,2190817,2190849,2190881,2190913,2116609,2190945,2190977,2191009,2191041,2117185,2191073,2191105,2191137,2191169]),
|
|
|
new Uint32Array([2228642,2228706,2228770,2228834,2228898,2228962,2229026,2229090,2229154,2229218,2229282,2229346,2229410,2229474,2229538,2229602]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0]),
|
|
|
new Uint32Array([23068672,23068672,23068672,0,0,0,23068672,23068672,23068672,0,23068672,23068672,23068672,23068672,0,0]),
|
|
|
new Uint32Array([2236641,2236673,2236705,2215809,2236738,2236801,2236833,2236865,2217921,2236865,2236897,2215873,2236929,2236961,2236993,2237025]),
|
|
|
new Uint32Array([2178017,6291456,2178049,6291456,2178081,6291456,2178113,6291456,2178145,6291456,2178177,6291456,2178209,6291456,2178241,6291456]),
|
|
|
new Uint32Array([10553858,2165314,10518722,6291456,10518818,0,10518914,2130690,10519010,2130786,10519106,2130882,10519202,2165378,10554050,2165506]),
|
|
|
new Uint32Array([0,0,2135491,2135587,2135683,2135779,2135875,2135971,2135971,2136067,2136163,2136259,2136355,2136355,2136451,2136547]),
|
|
|
new Uint32Array([23068672,23068672,23068672,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,23068672,6291456,6291456,6291456,23068672,6291456,6291456,6291456,6291456,23068672,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([23068672,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2213889,2213921,2213953,2213985,2214017,2214049,2214081,2194145,2214113,2214145,2214177,2214209,2214241,2214273,2214305,2214337]),
|
|
|
new Uint32Array([6291456,6291456,6291456,0,0,0,0,0,0,0,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,0,23068672,0,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([2100897,2100898,2100899,2150018,2100865,2100866,2100867,2100868,2150082,2108481,2109858,2109859,2105569,2105505,2098241,2105601]),
|
|
|
new Uint32Array([2097217,2097505,2097505,2097505,2097505,2165570,2165570,2165634,2165634,2165698,2165698,2097858,2097858,0,0,2097152]),
|
|
|
new Uint32Array([23068672,6291456,23068672,23068672,23068672,6291456,6291456,23068672,23068672,6291456,6291456,6291456,6291456,6291456,23068672,23068672]),
|
|
|
new Uint32Array([10503843,10503939,10504035,10504131,10504227,10504323,10504419,10504515,10504611,10504707,10504803,10504899,10504995,10491140,10491268,0]),
|
|
|
new Uint32Array([2173697,2173729,2148801,2173761,2143969,2173793,2173825,2153473,2173857,2173889,2173921,2173953,2173985,2173761,2174017,2174049]),
|
|
|
new Uint32Array([2242881,2242914,2242977,2243009,2243041,2243074,2243137,2243169,2243201,2243233,2243265,2243298,2243361,2243393,2243425,2243457]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([2222401,2222433,2222465,10531394,2222497,2222529,2222561,0,2222593,2222625,2222657,2222689,2222721,2222753,2222785,0]),
|
|
|
new Uint32Array([2244194,2244257,2244289,2244321,2244353,2244385,2244417,2244450,2244514,2244578,2244642,2236193,2244705,2244737,2244769,2244801]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456,23068672,23068672]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,23068672,23068672,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2105570,2156034,2126947,2156098,2153666,2127043,2127139,2156162,0,2127235,2156226,2156290,2156354,2156418,2127331,2127427]),
|
|
|
new Uint32Array([6291456,6291456,2148418,2148482,2148546,0,6291456,2148610,2186497,2186529,2148417,2148545,2148482,10495778,2143969,10495778]),
|
|
|
new Uint32Array([2183841,6291456,2183873,6291456,2183905,6291456,2183937,6291456,2183969,6291456,2184001,6291456,2184033,6291456,2184065,6291456]),
|
|
|
new Uint32Array([2187137,2187169,2187201,2187233,2187265,2187297,2187329,2187361,2187393,2187425,2187457,2187489,2187521,2187553,2187585,2187617]),
|
|
|
new Uint32Array([2184961,6291456,2184993,6291456,2185025,6291456,2185057,6291456,2185089,6291456,2185121,6291456,2185153,6291456,2185185,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,0,23068672,23068672,23068672,0,23068672,23068672,23068672,0,0]),
|
|
|
new Uint32Array([2173921,2173953,2173985,2174017,2174017,2174049,2174081,2174113,2174145,2174177,2149057,2230785,2173697,2173761,2173793,2174113]),
|
|
|
new Uint32Array([2212001,2212033,2212065,2212097,2212129,2212161,2212193,2212225,2212257,2212289,2212321,2212353,2212385,2212417,2212449,2207265]),
|
|
|
new Uint32Array([2234562,2234626,2234689,2234721,2234753,2234785,2234817,2234849,0,2234881,2234913,2234913,2234946,2235009,2235041,2209569]),
|
|
|
new Uint32Array([2194977,2195009,2195041,2195073,2195105,2195137,2195169,2195201,2195233,2195265,2195297,2195329,2195361,2195393,2195425,2195457]),
|
|
|
new Uint32Array([2192609,2230913,2230945,2152257,2116609,2230977,2231009,2200033,2231041,2231073,2231105,2212449,2231137,2231169,2231201,2231233]),
|
|
|
new Uint32Array([23068672,6291456,6291456,6291456,6291456,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2219969,2157121,2157441,2157505,2157889,2157953,2220001,2158465,2158529,10575585,2156994,2157058,2129923,2130019,2157122,2157186]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,6291456,6291456,6291456,18874368,18874368,18874368,0,0]),
|
|
|
new Uint32Array([2174081,2174113,2174145,2174177,2149057,2230785,2173697,2173761,2173793,2174113,2173985,2173953,2148481,2173601,2173633,2173665]),
|
|
|
new Uint32Array([2133089,2133281,2133281,2133281,2133281,2160577,2160577,2160577,2160577,2097441,2097441,2097441,2097441,2133857,2133857,2133857]),
|
|
|
new Uint32Array([23068672,6291456,0,0,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2182049,6291456,2182081,6291456,2182113,6291456,2182145,6291456,2182177,6291456,2182209,6291456,2182241,6291456,2182273,6291456]),
|
|
|
new Uint32Array([2178529,6291456,2178561,6291456,2178593,6291456,2178625,6291456,2178657,6291456,2178689,6291456,2178721,6291456,2178753,6291456]),
|
|
|
new Uint32Array([2221025,2221025,2221057,2221057,2159329,2159329,2159329,2159329,2097217,2097217,2158914,2158914,2158978,2158978,2159042,2159042]),
|
|
|
new Uint32Array([2169217,6291456,2169249,6291456,2169281,6291456,2169313,6291456,2169345,6291456,2169377,6291456,2169409,6291456,2169441,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2183329,6291456,2183361,6291456,2183393,6291456,2183425,6291456,2183457,6291456,2183489,6291456,2183521,6291456,2183553,6291456]),
|
|
|
new Uint32Array([2214849,2218433,2218465,2218497,2218529,2218561,2214881,2218593,2218625,2218657,2218689,2218721,2218753,2216545,2218785,2218817]),
|
|
|
new Uint32Array([2249346,2249409,2249442,2249506,2249570,2196705,2249633,2196833,2249665,2249697,2249729,2249761,2196993,2249794,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,0,0,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2182305,6291456,2182337,6291456,2182369,6291456,2182401,6291456,2182433,6291456,2182465,6291456,2182497,6291456,2182529,6291456]),
|
|
|
new Uint32Array([2112577,2098177,2098305,2108321,2108289,2100865,2113153,2108481,2113345,2113441,2100833,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2218721,2242401,2242434,2216385,2242498,2242562,2215009,2242625,2242657,2216481,2242689,2242721,2242754,2242818,2242818,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2187073,2187105,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,0,0,0,0,0,0,0,0,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672,0,0,0,0,0]),
|
|
|
new Uint32Array([2173985,2174017,2174017,2174049,2174081,2174113,2174145,2174177,2149057,2230785,2173697,2173761,2173793,2174113,2173985,2173953]),
|
|
|
new Uint32Array([2237537,2237569,2237601,2237633,2237665,2237697,2237729,2237761,2215937,2237793,2237826,2237889,2237921,2237953,2237985,2216001]),
|
|
|
new Uint32Array([2098305,2108321,2108289,2100865,2113153,2108481,2113345,2113441,2098209,2111137,0,2098241,2108353,2108417,2105825,0]),
|
|
|
new Uint32Array([2134145,2097153,2134241,0,2132705,2130977,2160065,2131297,0,2133089,2160577,2133857,2230817,0,2230849,0]),
|
|
|
new Uint32Array([2160002,2160066,2160130,2160194,2160258,2132066,2131010,2131106,2106018,2131618,2160322,2131298,2132034,2131938,2137410,2132226]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,0,0,0,0,0,0,0,0,0,0,0,6291456]),
|
|
|
new Uint32Array([2184449,6291456,2184481,6291456,2184513,6291456,2184545,6291456,2184577,6291456,2184609,6291456,2184641,6291456,2184673,6291456]),
|
|
|
new Uint32Array([0,6291456,6291456,0,6291456,0,0,6291456,6291456,0,6291456,0,0,6291456,0,0]),
|
|
|
new Uint32Array([2205729,2205761,2205793,2205825,2205857,2205889,2205921,2205953,2205985,2206017,2206049,2206081,2206113,2206145,2206177,2206209]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2143170,2168993,6291456,2169025,6291456,2169057,6291456,2169089,6291456,2143234,2169121,6291456,2169153,6291456,2169185,6291456]),
|
|
|
new Uint32Array([2110051,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([10485857,6291456,6291456,6291456,6291456,6291456,6291456,6291456,10495394,6291456,2098209,6291456,6291456,2097152,6291456,10531394]),
|
|
|
new Uint32Array([0,6291456,6291456,6291456,6291456,6291456,6291456,0,0,6291456,6291456,6291456,6291456,6291456,6291456,0]),
|
|
|
new Uint32Array([2214369,2234081,2234113,2234145,2234177,2234209,2234241,2234273,2234305,2234338,2234401,2234433,2234465,2230977,2234497,2234529]),
|
|
|
new Uint32Array([2220641,2220641,2220673,2220673,2220673,2220673,2220705,2220705,2220705,2220705,2220737,2220737,2220737,2220737,2220769,2220769]),
|
|
|
new Uint32Array([0,0,2198209,2198241,2198273,2198305,2198337,2198369,0,0,2198401,2198433,2198465,0,0,0]),
|
|
|
new Uint32Array([14680064,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2173985,2173953,2148481,2173601,2173633,2173665,2173697,2173729,2148801,2173761,2143969,2173793,2173825,2153473,2173857,2173889]),
|
|
|
new Uint32Array([2209601,2209633,2209665,2209697,2209729,2209761,2209793,2209825,2209857,2209889,2209921,2209953,2209985,2210017,2210049,2210081]),
|
|
|
new Uint32Array([10501539,10501635,10501731,10501827,10501923,10502019,2098209,2111137,2105505,2098241,2108353,2108417,2105825,2111713,2100897,2111905]),
|
|
|
new Uint32Array([2220289,2220289,2220321,2220321,2220321,2220321,2220353,2220353,2220353,2220353,2220385,2220385,2220385,2220385,2220417,2220417]),
|
|
|
new Uint32Array([2173697,2173729,2148801,2173761,2143969,2173793,2173825,2153473,2173857,2173889,2173921,2173953,2173985,2174017,2174017,2174049]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,6291456,6291456,6291456,0,0]),
|
|
|
new Uint32Array([6291456,6291456,23068672,23068672,23068672,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2113153,2108481,2113345,2113441,2098209,2111137,2105505,2098241,2108353,2108417,2105825,2111713,2100897,2111905,2105473,2105569]),
|
|
|
new Uint32Array([2222818,2222882,2222946,2223010,2223074,2223138,2223202,2223266,2223330,2223394,2223458,2223522,2223586,2223650,2223714,2223778]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672]),
|
|
|
new Uint32Array([2248801,2248834,2248897,2248929,2248961,2248993,2249025,2249057,2249089,2249122,2219393,2249185,2249217,2249249,2249281,2249313]),
|
|
|
new Uint32Array([0,2179553,2179585,2179617,2179649,2144001,2179681,2179713,2179745,2179777,2179809,2156705,2179841,2156833,2179873,2179905]),
|
|
|
new Uint32Array([6291456,23068672,6291456,2145602,23068672,23068672,23068672,23068672,23068672,23068672,0,23068672,23068672,6291456,0,0]),
|
|
|
new Uint32Array([2204705,2204737,2204769,2204801,2204833,2204865,2204897,2204929,2204961,2204993,2205025,2205057,2205089,2205121,2205153,2205185]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2168577,6291456,2168609,6291456,2168641,6291456,2168673,6291456,2168705,6291456,2168737,6291456,2168769,6291456,2168801,6291456]),
|
|
|
new Uint32Array([10485857,10485857,10485857,10485857,10485857,10485857,10485857,10485857,10485857,10485857,10485857,2097152,4194304,4194304,0,0]),
|
|
|
new Uint32Array([2238497,2238529,2216033,2238562,2238625,2238657,2238689,2219617,2238721,2238753,2238785,2238817,2238850,2238913,2238945,2238977]),
|
|
|
new Uint32Array([2143042,6291456,2143106,2143106,2168833,6291456,2168865,6291456,6291456,2168897,6291456,2168929,6291456,2168961,6291456,2143170]),
|
|
|
new Uint32Array([6291456,6291456,23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2204193,2204225,2204257,2204289,2204321,2204353,2204385,2204417,2204449,2204481,2204513,2204545,2204577,2204609,2204641,2204673]),
|
|
|
new Uint32Array([2202753,6291456,2202785,6291456,2202817,6291456,2202849,6291456,2202881,6291456,2202913,6291456,2202945,6291456,2202977,6291456]),
|
|
|
new Uint32Array([23068672,23068672,2190657,6291456,0,0,0,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2108353,2108417,2105825,2111713,2100897,2111905,2105473,2105569,2105601,2112289,2108193,2112481,2112577,2098177,2098305,2108321]),
|
|
|
new Uint32Array([2189249,6291456,2189281,6291456,2189313,6291456,2189345,6291456,2189377,6291456,2189409,6291456,2189441,6291456,2189473,6291456]),
|
|
|
new Uint32Array([2147394,2147458,2147522,2147586,2147650,2147714,2147778,2147842,2147394,2147458,2147522,2147586,2147650,2147714,2147778,2147842]),
|
|
|
new Uint32Array([2228450,2228514,2228578,0,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,6291456,6291456]),
|
|
|
new Uint32Array([2162562,2162626,2131362,2162690,2159938,2160002,2162754,2162818,2160130,2162882,2160194,2160258,2160834,2160898,2161026,2161090]),
|
|
|
new Uint32Array([2184193,6291456,2184225,6291456,2184257,6291456,2184289,6291456,2184321,6291456,2184353,6291456,2184385,6291456,2184417,6291456]),
|
|
|
new Uint32Array([2175361,2175393,2175425,2175457,2175489,2175521,2175553,2175585,2175617,2175649,2175681,2175713,2175745,2175777,2175809,2175841]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,0,6291456,6291456,6291456,6291456,0,0]),
|
|
|
new Uint32Array([2190017,6291456,2190049,6291456,2190081,6291456,2190113,6291456,2190145,6291456,2190177,6291456,2190209,6291456,2190241,6291456]),
|
|
|
new Uint32Array([2108289,2100865,2113153,2108481,2113345,2113441,2098209,2111137,2105505,2098241,0,2108417,0,2111713,2100897,2111905]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,2143298,2143298,2143298,2143362,2143362,2143362,2143426,2143426,2143426,2171105,6291456,2171137]),
|
|
|
new Uint32Array([2120162,2120258,2151618,2151682,2151746,2151810,2151874,2151938,2152002,2120035,2120131,2120227,2152066,2120323,2152130,2120419]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2238017,2238049,2238081,2238113,2238145,2238177,2238209,2238241,2207937,2218177,2238273,2238305,2238337,2238370,2238433,2238465]),
|
|
|
new Uint32Array([2233153,2233185,2233185,2233185,2233218,2233281,2233313,2233345,2233378,2233441,2233473,2233505,2233537,2233569,2233601,2233633]),
|
|
|
new Uint32Array([6291456,6291456,2145922,6291456,6291456,6291456,6291456,2145986,6291456,6291456,6291456,6291456,2146050,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2100833,2100737,2098337,2101441,2101569,2101697,2101825,2101953,2102081,2102209,10502113,10562017,10610401,10502177,10610433,10538049]),
|
|
|
new Uint32Array([2099521,2099105,2120705,2098369,2120801,2103361,2097985,2098433,2121377,2121473,2099169,2099873,2098401,2099393,2152609,2100033]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,23068672,23068672,23068672]),
|
|
|
new Uint32Array([6291456,0,6291456,6291456,6291456,6291456,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,0,6291456,0,23068672,23068672,23068672,23068672,23068672,23068672,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,0,6291456,6291456,6291456,6291456,6291456,0,0,23068672,6291456,23068672,23068672]),
|
|
|
new Uint32Array([0,2105921,2097729,0,2097377,0,0,2106017,2133281,2097505,2105889,0,2097697,2135777,2097633,2097441]),
|
|
|
new Uint32Array([2132514,2132610,2160386,2133090,2133186,2160450,2160514,2133282,2160578,2133570,2106178,2160642,2133858,2160706,2160770,2134146]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,23068672,23068672,0,0,0,0,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,23068672,23068672,6291456,23068672,23068672,6291456,23068672,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2182817,6291456,2182849,6291456,2182881,6291456,2182913,6291456,2182945,6291456,2182977,6291456,2183009,6291456,2183041,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,2197217,6291456,2117377,2197249,2197281,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,0,6291456,6291456,6291456,6291456,0,6291456]),
|
|
|
new Uint32Array([6291456,6291456,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2193505,2193537,2193569,2193601,2193633,2193665,2193697,2193729,2193761,2193793,2193825,2193857,2193889,2193921,2193953,2193985]),
|
|
|
new Uint32Array([0,0,2097729,0,0,0,0,2106017,0,2097505,0,2097185,0,2135777,2097633,2097441]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,0,0,0,2190689]),
|
|
|
new Uint32Array([2218145,2214785,2207937,2218177,2218209,2192961,2210113,2212769,2218241,2218273,2216129,2218305,2216161,2218337,2218369,2218401]),
|
|
|
new Uint32Array([2184097,6291456,2184129,6291456,2184161,6291456,6291456,6291456,6291456,6291456,2146818,2183329,6291456,6291456,2142978,6291456]),
|
|
|
new Uint32Array([6291456,0,23068672,23068672,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,2190753,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,0,0,0,0,0,0,23068672,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,23068672,6291456,23068672,6291456,23068672,6291456,6291456,6291456,6291456,23068672,23068672]),
|
|
|
new Uint32Array([0,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2097281,2105921,2097729,2106081,2097377,2097601,2162337,2106017,2133281,2097505,0,2097185,2097697,2135777,2097633,2097441]),
|
|
|
new Uint32Array([2176641,6291456,2176673,6291456,2176705,6291456,2176737,6291456,2176769,6291456,2176801,6291456,2176833,6291456,2176865,6291456]),
|
|
|
new Uint32Array([2196641,2208641,2208673,2208705,2208737,2208769,2208801,2208833,2208865,2208897,2208929,2208961,2208993,2209025,2209057,2209089]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,0,6291456,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456]),
|
|
|
new Uint32Array([2167617,2167649,2167681,2167713,2167745,2167777,2167809,6291456,2167841,2167873,2167905,2167937,2167969,2168001,2168033,4240130]),
|
|
|
new Uint32Array([2165122,2163970,2164034,2164098,2164162,2164226,2164290,2164354,2164418,2164482,2164546,2133122,2134562,2132162,2132834,2136866]),
|
|
|
new Uint32Array([2112481,2112577,2098177,2098305,2108321,2108289,2100865,2113153,2108481,2113345,2113441,14680064,14680064,14680064,14680064,14680064]),
|
|
|
new Uint32Array([2149057,2230753,2148481,2173601,2173633,2173665,2173697,2173729,2148801,2173761,2143969,2173793,2173825,2153473,2173857,2173889]),
|
|
|
new Uint32Array([0,0,23068672,6291456,0,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,6291456,6291456]),
|
|
|
new Uint32Array([2148801,2173761,2143969,2173793,2173825,2153473,2173857,2173889,2173921,2173953,2173985,2174017,2174017,2174049,2174081,2174113]),
|
|
|
new Uint32Array([2243489,2243521,2243554,2243618,2243681,2243714,2243777,2243810,2243873,2243905,2216673,2243938,2244002,2244065,2244098,2244161]),
|
|
|
new Uint32Array([2105473,2105569,2105601,2112289,0,2112481,2112577,2098177,2098305,2108321,2108289,2100865,2113153,2108481,2113345,2113441]),
|
|
|
new Uint32Array([2100897,2111905,2105473,2105569,2105601,2112289,2108193,2112481,2112577,2098177,2098305,2108321,2108289,2100865,2113153,2108481]),
|
|
|
new Uint32Array([2125346,2153410,2153474,2127394,2153538,2153602,2153666,2153730,2105507,2105476,2153794,2153858,2153922,2153986,2154050,2105794]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2175777,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2201377,6291456,2201409,6291456,2201441,6291456,2201473,6291456,2201505,6291456,2201537,6291456,2201569,6291456,6291456,23068672]),
|
|
|
new Uint32Array([10537282,10495683,2148738,2148802,2148866,0,6291456,2148930,2186561,2173473,2148737,2148865,2148802,10495779,10495875,10495971]),
|
|
|
new Uint32Array([0,0,0,0,0,23068672,23068672,0,6291456,6291456,6291456,0,0,0,0,0]),
|
|
|
new Uint32Array([2161154,2161410,2138658,2161474,2161538,2097666,2097186,2097474,2162946,2132450,2163010,2163074,2136162,2163138,2161666,2161730]),
|
|
|
new Uint32Array([2148481,2173601,2173633,2173665,2173697,2173729,2148801,2173761,2143969,2173793,2173825,2153473,2173857,2173889,2173921,2173953]),
|
|
|
new Uint32Array([0,0,0,0,0,0,23068672,23068672,0,0,0,0,2145410,2145474,0,6291456]),
|
|
|
new Uint32Array([2125730,2125699,2125795,2125891,2125987,2154114,2154178,2154242,2154306,2154370,2154434,2154498,2126082,2126178,2126274,2126083]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,0,23068672,23068672,23068672,0,23068672,23068672,23068672,23068672,6291456,0]),
|
|
|
new Uint32Array([2188161,2188193,2188225,2188257,2188289,2188321,2188353,2188385,2188417,2188449,2188481,2188513,2188545,2188577,2188609,0]),
|
|
|
new Uint32Array([2220161,2220161,2220193,2220193,2220193,2220193,2220225,2220225,2220225,2220225,2220257,2220257,2220257,2220257,2220289,2220289]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,0,0,23068672,23068672,0,0,23068672,23068672,23068672,0,0]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,0,0,0,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2189505,6291456,2189537,6291456,2189569,6291456,2189601,6291456,2189633,6291456,2189665,6291456,2189697,6291456,2189729,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,10532162,10532226,10532290,10532354,10532418,10532482,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,0,0,2186177,2186209,2186241,2186273,2186305,2186337,0,0]),
|
|
|
new Uint32Array([2219490,2219554,2219617,2219649,2219681,2219714,2219778,2219842,2219905,2219937,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,23068672,23068672,23068672,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,6291456]),
|
|
|
new Uint32Array([2113345,2113441,2098209,2111137,2105505,2098241,2108353,2108417,2105825,2111713,2100897,2111905,2105473,2105569,2105601,2112289]),
|
|
|
new Uint32Array([2196993,2197025,2197057,2197089,2197121,2197153,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2200609,2150786,2150850,2150914,2150978,2151042,2106562,2151106,2150562,2151170,2151234,2151298,2151362,2151426,2151490,2151554]),
|
|
|
new Uint32Array([2248193,2248226,2248289,2248321,2248353,2248385,2248418,2248482,2248545,2248577,2248609,2248642,2248705,2248738,2219361,2219361]),
|
|
|
new Uint32Array([6291456,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2179297,6291456,2179329,6291456,2179361,6291456,2179393,6291456,2179425,6291456,2179457,6291456,2179489,6291456,2179521,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,23068672,6291456,6291456,6291456,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2113153,2108481,2113345,2113441,2230689,2230721,0,0,2148481,2173601,2173633,2173665,2173697,2173729,2148801,2173761]),
|
|
|
new Uint32Array([2170593,6291456,2170625,6291456,2170657,6291456,2170689,2170721,6291456,2170753,6291456,6291456,2170785,6291456,2170817,2170849]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,6291456]),
|
|
|
new Uint32Array([2134562,2132162,2132834,2136866,2136482,2164610,2164674,2164738,2164802,2132802,2132706,2164866,2132898,2164930,2164994,2165058]),
|
|
|
new Uint32Array([6291456,6291456,2098337,2101441,10531458,2153473,6291456,6291456,10531522,2100737,2108193,6291456,2106499,2106595,2106691,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([23068672,6291456,23068672,23068672,23068672,6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0]),
|
|
|
new Uint32Array([2188993,6291456,2189025,6291456,2189057,6291456,2189089,6291456,2189121,6291456,2189153,6291456,2189185,6291456,2189217,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2229666,2229730,2229794,2229858,2229922,2229986,2230050,2230114,2230178,2230242,2230306,2230370,2230434,2230498,2230562,2230626]),
|
|
|
new Uint32Array([2205217,2205249,2205281,2205313,2205345,2205377,2205409,2205441,2205473,2205505,2205537,2205569,2205601,2205633,2205665,2205697]),
|
|
|
new Uint32Array([2195329,2142433,2231585,2231617,2231649,2231681,2118241,2117473,2231713,2231745,2231777,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,0,6291456,0,0,0,6291456,6291456,6291456,6291456,0,0,23068672,6291456,23068672,23068672]),
|
|
|
new Uint32Array([2173601,2173761,2174081,2173569,2174241,2174113,2173953,6291456,2174305,6291456,2174337,6291456,2174369,6291456,2174401,6291456]),
|
|
|
new Uint32Array([2152450,2152514,2099653,2104452,2099813,2122243,2099973,2152578,2122339,2122435,2122531,2122627,2122723,2104580,2122819,2152642]),
|
|
|
new Uint32Array([2163394,2159746,2163458,2131362,2163522,2160130,2163778,2132226,2163842,2132898,2163906,2161410,2138658,2097666,2136162,2163650]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2129730,2129762,2129858,2129731,2129827,2156482,2156482,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2138179,2138275,2138371,2138467,2134243,2134435,2138563,2138659,2138755,2138851,2138947,2139043,2138947,2138755,2139139,2139235]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,0,0,0,0,0,6291456,0,0]),
|
|
|
new Uint32Array([2224866,2224930,2224994,2225058,2225122,2225186,2225250,2225314,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2169473,6291456,2169505,6291456,2169537,6291456,2169569,6291456,2169601,6291456,2169633,6291456,2169665,6291456,2169697,6291456]),
|
|
|
new Uint32Array([2141542,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2220801,2220801,2220801,2220801,2220833,2220833,2220865,2220865,2220865,2220865,2220897,2220897,2220897,2220897,2139873,2139873]),
|
|
|
new Uint32Array([0,0,0,0,0,23068672,23068672,0,0,0,0,0,0,0,6291456,0]),
|
|
|
new Uint32Array([2173697,2173761,2173793,2174113,2173985,2173953,2148481,2173601,2173633,2173665,2173697,2173729,2148801,2173761,2143969,2173793]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,0,0,0,0,0,0,0,0,0,0,0,6291456]),
|
|
|
new Uint32Array([2136482,2164610,2164674,2164738,2164802,2132802,2132706,2164866,2132898,2164930,2164994,2165058,2165122,2132802,2132706,2164866]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,0,0,0,0,0,0,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([2207649,2207681,2207713,2207745,2207777,2207809,2207841,2207873,2207905,2207937,2207969,2208001,2208033,2208065,2208097,2208129]),
|
|
|
new Uint32Array([2123683,2105092,2152706,2123779,2105220,2152770,2100453,2098755,2123906,2124002,2124098,2124194,2124290,2124386,2124482,2124578]),
|
|
|
new Uint32Array([0,2221185,2221217,10609857,10609857,10489601,10489697,10609889,10609921,2141729,2141793,2221345,2221377,2221409,2221441,2187073]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,0,0,0,6291456,0,0,0,0,0,0,0,10485857]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([2108417,2181185,2181217,2181249,2170433,2170401,2181281,2181313,2181345,2181377,2181409,2181441,2181473,2181505,2170529,2181537]),
|
|
|
new Uint32Array([2185217,6291456,2185249,6291456,2185281,6291456,2185313,6291456,2185345,6291456,2185377,6291456,2185409,6291456,2185441,6291456]),
|
|
|
new Uint32Array([2203553,6291456,2203585,6291456,6291456,6291456,2203617,6291456,2203649,6291456,2203681,6291456,2203713,6291456,2203745,6291456]),
|
|
|
new Uint32Array([2191201,2191233,2191265,2191297,2191329,2191361,2191393,2117377,2191425,2191457,2191489,2191521,2191553,2191585,2191617,2117953]),
|
|
|
new Uint32Array([6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,23068672]),
|
|
|
new Uint32Array([2239649,2216065,2212769,2239681,2239713,2239745,2239778,2239841,2239873,2239905,2239937,2218273,2239969,2240002,2240065,2240097]),
|
|
|
new Uint32Array([2203969,2204001,2181345,2204033,2204065,6291456,2204097,6291456,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2102402,2102403,6291456,2110050]),
|
|
|
new Uint32Array([6291456,6291456,6291456,2186721,6291456,6291456,6291456,6291456,2186753,2186785,2186817,2173569,2186849,10496355,10495395,10575489]),
|
|
|
new Uint32Array([2149890,2108323,2149954,6291456,2113441,6291456,2149057,6291456,2113441,6291456,2105473,2167265,2111137,2105505,6291456,2108353]),
|
|
|
new Uint32Array([2203009,6291456,2203041,6291456,2203073,6291456,2203105,6291456,2203137,6291456,2203169,6291456,2203201,6291456,2203233,6291456]),
|
|
|
new Uint32Array([2181793,6291456,2181825,6291456,2181857,6291456,2181889,6291456,2181921,6291456,2181953,6291456,2181985,6291456,2182017,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2140964,2141156,2140966,2141158,2141350]),
|
|
|
new Uint32Array([0,0,0,0,0,0,0,0,0,0,0,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([2197665,2114113,2114209,2197697,2197729,2114305,2197761,2114401,2114497,2197793,2114593,2114689,2114785,2114881,2114977,2197825]),
|
|
|
new Uint32Array([2225378,2225442,2225506,2225570,2225634,2225698,2225762,2225826,2225890,2225954,2226018,2226082,2226146,2226210,2226274,2226338]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2112577,2098177,2098305,2108321,2108289,2100865,2113153,2108481,2113345,2113441,2098209,2111137,2105505,2098241,2108353,2108417]),
|
|
|
new Uint32Array([2108353,2108417,0,2105601,2108193,2157121,2157313,2157377,2157441,2100897,6291456,2108419,2173953,2173633,2173633,2173953]),
|
|
|
new Uint32Array([2111713,2173121,2111905,2098177,2173153,2173185,2173217,2113153,2113345,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2134435,2134531,2134627,2134723,2134723,2134819,2134819,2134915,2134915,2135011,2105987,2135107,2135203,2135299,2131587,2135395]),
|
|
|
new Uint32Array([2098337,2101441,2101569,2101697,2101825,2101953,2102081,2102209,2100833,2100737,2098337,2101441,2101569,2101697,2101825,2101953]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0]),
|
|
|
new Uint32Array([2197665,2114113,2114209,2197697,2197729,2114305,2197761,2114401,2114497,2197793,2114593,2114689,2114785,2114881,2114977,0]),
|
|
|
new Uint32Array([2115265,2115361,2115457,2115553,2115649,2115745,2115841,2115937,2116033,2116129,2116225,2116321,2150658,2150722,2200193,6291456]),
|
|
|
new Uint32Array([0,0,0,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,23068672,23068672,23068672]),
|
|
|
new Uint32Array([2173281,6291456,2173313,6291456,2173345,6291456,2173377,6291456,0,0,10532546,6291456,6291456,6291456,10562017,2173441]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,0,0]),
|
|
|
new Uint32Array([23068672,23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2159426,2159490,2159554,2159362,2159618,2159682,2139522,2136450,2159746,2159810,2159874,2130978,2131074,2131266,2131362,2159938]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2203233,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2203265,6291456,2203297,6291456,2203329,2203361,6291456]),
|
|
|
new Uint32Array([2134146,2139426,2160962,2134242,2161218,2161282,2161346,2161410,2138658,2134722,2134434,2134818,2097666,2097346,2097698,2105986]),
|
|
|
new Uint32Array([2194017,2194049,2194081,2194113,2194145,2194177,2194209,2194241,2194273,2194305,2194337,2194369,2194401,2194433,2194465,2194497]),
|
|
|
new Uint32Array([0,23068672,23068672,23068672,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456]),
|
|
|
new Uint32Array([10610561,2098209,2111137,2105505,2098241,2108353,2108417,2105825,2111713,2100897,2111905,2105473,2105569,2105601,2112289,2108193]),
|
|
|
new Uint32Array([2190273,6291456,2190305,6291456,2190337,6291456,2190369,6291456,2190401,6291456,2190433,6291456,2190465,6291456,2190497,6291456]),
|
|
|
new Uint32Array([0,0,0,0,0,0,0,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2181121,6291456,2188865,6291456,6291456,2188897,6291456,6291456,6291456,6291456,6291456,6291456,2111905,2100865,2188929,2188961]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,0,0,2180673,2180705,2180737,2180769,2180801,2180833,0,0]),
|
|
|
new Uint32Array([2098081,2099521,2099105,2120705,2098369,2120801,2103361,2097985,2098433,2121377,2121473,2099169,2099873,2098401,2099393,2152609]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2150402]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,2145666,2145730,6291456,6291456]),
|
|
|
new Uint32Array([2133187,2133283,2133283,2133379,2133475,2133571,2133667,2133667,2133763,2133859,2133955,2134051,2134147,2134147,2134243,2134339]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2102404,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2239010,2239073,2239105,2239137,2239169,2210113,2239201,2239234,2239298,2239362,2239425,2239458,2239521,2239553,2239585,2239617]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,2100612,6291456,6291456,6291456,6291456,6291456,6291456,6291456,10485857]),
|
|
|
new Uint32Array([2195489,2195521,2195553,2195585,2195617,2195649,2117857,2195681,2195713,2195745,2195777,2195809,2195841,2195873,2195905,2195937]),
|
|
|
new Uint32Array([2217697,2217729,2217761,2217793,2217825,2217857,2217889,2217921,2217953,2215873,2217985,2215905,2218017,2218049,2218081,2218113]),
|
|
|
new Uint32Array([2220033,2220033,2220065,2220065,2220065,2220065,2220097,2220097,2220097,2220097,2220129,2220129,2220129,2220129,2220161,2220161]),
|
|
|
new Uint32Array([0,2097153,2134241,0,2132705,0,0,2131297,0,2133089,0,2133857,0,2220769,0,2230881]),
|
|
|
new Uint32Array([2211233,2218849,2216673,2218881,2218913,2218945,2218977,2219009,2216833,2219041,2215137,2219073,2216865,2209505,2219105,2216897]),
|
|
|
new Uint32Array([6291456,6291456,2202273,6291456,2202305,6291456,2202337,6291456,2202369,6291456,2202401,6291456,2202433,6291456,2202465,6291456]),
|
|
|
new Uint32Array([0,23068672,23068672,18923394,23068672,18923458,18923522,18884099,18923586,18884195,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([2134434,2134818,2097666,2097186,2097474,2097698,2105986,2131586,2132450,2131874,2131778,2135970,2135778,2161602,2136162,2161666]),
|
|
|
new Uint32Array([2201121,6291456,2201153,6291456,2201185,6291456,2201217,6291456,2201249,6291456,2201281,6291456,2201313,6291456,2201345,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,6291456,6291456]),
|
|
|
new Uint32Array([2211041,2211073,2211105,2211137,2211169,2211201,2211233,2211265,2211297,2211329,2211361,2211393,2211425,2211457,2211489,2211521]),
|
|
|
new Uint32Array([2195969,2196001,2196033,2196065,2196097,2196129,2196161,2196193,2196225,2196257,2196289,2196321,2196353,2196385,2196417,2196449]),
|
|
|
new Uint32Array([2162337,2097633,2097633,2097633,2097633,2132705,2132705,2132705,2132705,2097153,2097153,2097153,2097153,2133089,2133089,2133089]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,0,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,2148545,6291456,2173473,6291456,2148865,6291456,2173505,6291456,2173537,6291456,2173569,6291456,2149121,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,6291456,0,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0]),
|
|
|
new Uint32Array([2105825,2111713,2100897,2111905,2105473,2105569,2105601,2112289,2108193,2112481,2112577,2098177,2098305,2108321,2108289,2100865]),
|
|
|
new Uint32Array([2207137,2207169,2207201,2207233,2207265,2207297,2207329,2207361,2207393,2207425,2207457,2207489,2207521,2207553,2207585,2207617]),
|
|
|
new Uint32Array([2219137,2216961,2219169,2219201,2219233,2219265,2219297,2217025,2215041,2219329,2217057,2219361,2217089,2219393,2197121,2219426]),
|
|
|
new Uint32Array([6291456,6291456,23068672,23068672,23068672,6291456,6291456,0,23068672,23068672,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2202113,2204129,2188673,2204161]),
|
|
|
new Uint32Array([2105505,2098241,2108353,2108417,2105825,2111713,2100897,2111905,2105473,2105569,2105601,2112289,2108193,2112481,2112577,2098177]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,0,0]),
|
|
|
new Uint32Array([2216385,2118721,2216417,2216449,2216481,2216513,2216545,2211233,2216577,2216609,2216641,2216673,2216705,2216737,2216737,2216769]),
|
|
|
new Uint32Array([2216801,2216833,2216865,2216897,2216929,2216961,2216993,2215169,2217025,2217057,2217089,2217121,2217154,2217217,0,0]),
|
|
|
new Uint32Array([0,0,2197825,2197857,2197889,2197921,2197953,2197985,0,0,2198017,2198049,2198081,2198113,2198145,2198177]),
|
|
|
new Uint32Array([2211553,2210081,2211585,2211617,2211649,2211681,2211713,2211745,2211777,2211809,2209569,2211841,2211873,2211905,2211937,2211969]),
|
|
|
new Uint32Array([0,0,2105825,0,0,2111905,2105473,0,0,2112289,2108193,2112481,2112577,0,2098305,2108321]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2150146,6291456,6291456,6291456]),
|
|
|
new Uint32Array([0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([14680064,14680064,14680064,14680064,14680064,14680064,14680064,14680064,14680064,14680064,14680064,14680064,14680064,6291456,6291456,14680064]),
|
|
|
new Uint32Array([2098657,2098049,2200705,2123489,2123681,2200737,2098625,2100321,2098145,2100449,2098017,2098753,2200769,2200801,2200833,0]),
|
|
|
new Uint32Array([23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2220929,2220929,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2133857,2134145,2134145,2134145,2134145,2134241,2134241,2134241,2134241,2105889,2105889,2105889,2105889,2097185,2097185,2097185]),
|
|
|
new Uint32Array([0,0,0,0,0,0,0,0,0,0,0,0,10499619,10499715,10499811,10499907]),
|
|
|
new Uint32Array([2166914,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,0]),
|
|
|
new Uint32Array([0,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([6291456,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23068672]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,0,0,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,0,0,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([2182561,6291456,2182593,6291456,2182625,6291456,2182657,6291456,2182689,6291456,2182721,6291456,2182753,6291456,2182785,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2097152,0,0,0,2097152,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,6291456,23068672,23068672]),
|
|
|
new Uint32Array([2247554,2247618,2247681,2247713,2247745,2247778,2247841,2247873,2247905,2247937,2247969,2248001,2248033,2248066,2248129,2248161]),
|
|
|
new Uint32Array([6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,2144322,2144386,2144450,2144514,2144578,2144642,2144706,2144770]),
|
|
|
new Uint32Array([23068672,23068672,23068672,6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2113153,2108481,2113345,2113441,2098209,2111137,0,2098241,2108353,2108417,2105825,0,0,2111905,2105473,2105569]),
|
|
|
new Uint32Array([2152194,2121283,2103684,2103812,2097986,2098533,2097990,2098693,2098595,2098853,2099013,2103940,2121379,2121475,2121571,2104068]),
|
|
|
new Uint32Array([2206241,2206273,2206305,2206337,2206369,2206401,2206433,2206465,2206497,2206529,2206561,2206593,2206625,2206657,2206689,2206721]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,16777216,16777216,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,23068672,23068672,10538818,10538882,6291456,6291456,2150338]),
|
|
|
new Uint32Array([6291456,6291456,6291456,0,0,0,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2215905,2215937,2215969,2216001,2216033,2216065,2216097,2216129,2216161,2216193,2216225,2216257,2105441,2216289,2216321,2216353]),
|
|
|
new Uint32Array([2097152,2097152,2097152,2097152,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2146881,2146945,2147009,2147073,2147137,2147201,2147265,2147329]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,6291456,23068672,23068672]),
|
|
|
new Uint32Array([0,0,0,0,0,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2122915,2123011,2123107,2104708,2123203,2123299,2123395,2100133,2104836,2100290,2100293,2104962,2104964,2098052,2123491,2123587]),
|
|
|
new Uint32Array([23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456]),
|
|
|
new Uint32Array([6291456,2171169,6291456,2171201,6291456,2171233,6291456,2171265,6291456,2171297,6291456,2171329,6291456,6291456,2171361,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2199361,2199393,2199425,2199457,2199489,2199521,2199553,2199585,2199617,2199649,2199681,2199713,2199745,2199777,2199809,0]),
|
|
|
new Uint32Array([2113729,2113825,2113921,2114017,2114113,2114209,2114305,2114401,2114497,2114593,2114689,2114785,2114881,2114977,2115073,2115169]),
|
|
|
new Uint32Array([2227426,2227490,2227554,2227618,2227682,2227746,2227810,2227874,2227938,2228002,2228066,2228130,2228194,2228258,2228322,2228386]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,0,0,6291456,6291456]),
|
|
|
new Uint32Array([2112577,2098177,2098305,2108321,2108289,2100865,2113153,2108481,2113345,2113441,2166594,2127298,2166658,2142978,2141827,2166722]),
|
|
|
new Uint32Array([2203393,6291456,2203425,6291456,2203457,6291456,2203489,6291456,6291456,6291456,6291456,2203521,6291456,2181249,6291456,6291456]),
|
|
|
new Uint32Array([6291456,2148481,2173601,2173633,2173665,2173697,2173729,2148801,2173761,2143969,2173793,2173825,2153473,2173857,2173889,2173921]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,0,6291456]),
|
|
|
new Uint32Array([0,0,0,2220961,2220961,2220961,2220961,2144193,2144193,2159201,2159201,2159265,2159265,2144194,2220993,2220993]),
|
|
|
new Uint32Array([2100289,2098657,2098049,2200705,2123489,2123681,2200737,2098625,2100321,2098145,2100449,2098017,2098753,2098977,2150241,2150305]),
|
|
|
new Uint32Array([2210593,2191777,2210625,2210657,2210689,2210721,2210753,2210785,2210817,2210849,2191265,2210881,2210913,2210945,2210977,2211009]),
|
|
|
new Uint32Array([14680064,14680064,14680064,14680064,14680064,14680064,14680064,14680064,14680064,14680064,14680064,14680064,14680064,14680064,14680064,14680064]),
|
|
|
new Uint32Array([2139811,2139907,2097284,2105860,2105988,2106116,2106244,2097444,2097604,2097155,10485778,10486344,2106372,6291456,0,0]),
|
|
|
new Uint32Array([2108321,2108289,2113153,2098209,2180865,2180897,2180929,2111137,2098241,2108353,2170241,2170273,2180961,2105825,6291456,2105473]),
|
|
|
new Uint32Array([0,0,0,0,0,0,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2172385,6291456,2172417,6291456,2172449,6291456,2172481,6291456,2172513,6291456,2172545,6291456,2172577,6291456,2172609,6291456]),
|
|
|
new Uint32Array([0,0,23068672,23068672,6291456,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([2174145,2174177,2149057,2230785,2173697,2173761,2173793,2174113,2173985,2173953,2174369,2174369,0,0,2100833,2100737]),
|
|
|
new Uint32Array([2100033,2099233,2122017,2200641,2098113,2121537,2103201,2200673,2104033,2121857,2121953,2122401,2099649,2099969,2123009,2100129]),
|
|
|
new Uint32Array([2173825,2153473,2173857,2173889,2173921,2173953,2173985,2174017,2174017,2174049,2174081,2174113,2174145,2174177,2149057,2230785]),
|
|
|
new Uint32Array([2178273,6291456,2178305,6291456,2178337,6291456,2178369,6291456,2178401,6291456,2178433,6291456,2178465,6291456,2178497,6291456]),
|
|
|
new Uint32Array([2173985,2173761,2174017,2174049,2174081,2174113,2174145,2174177,2149057,2230753,2148481,2173601,2173633,2173665,2173697,2173729]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([0,0,0,6291456,6291456,0,0,0,6291456,6291456,6291456,0,0,0,6291456,6291456]),
|
|
|
new Uint32Array([2196481,2196513,2196545,2196577,2196609,2196641,2196673,2196705,2196737,2196769,2196801,2196833,2196865,2196897,2196929,2196961]),
|
|
|
new Uint32Array([2200417,2119681,2200449,2153313,2199841,2199873,2199905,2200481,2200513,2200545,2200577,2119105,2119201,2119297,2119393,2119489]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,0,0,0,0,0,0,0,0,0,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,6291456,6291456,6291456,6291456,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([0,0,23068672,23068672,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2231809,2231841,0,0,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2170369,2105569,2098305,2108481,2173249,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,6291456]),
|
|
|
new Uint32Array([2100897,2111905,2105473,2105569,2105601,0,2108193,0,0,0,2098305,2108321,2108289,2100865,2113153,2108481]),
|
|
|
new Uint32Array([2100897,2100897,2105569,2105569,6291456,2112289,2149826,6291456,6291456,2112481,2112577,2098177,2098177,2098177,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,0,0,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,2169953,2169985,6291456,2170017,6291456,2170049,2170081,6291456,2170113,2170145,2170177,6291456,6291456,2170209,2170241]),
|
|
|
new Uint32Array([6291456,6291456,0,0,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2181121,2105505,2181153,2167617,2180961]),
|
|
|
new Uint32Array([0,0,0,0,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2200865,6291456,2200897,6291456,2200929,6291456,2200961,6291456,2200993,6291456,2201025,6291456,2201057,6291456,2201089,6291456]),
|
|
|
new Uint32Array([2127650,2127746,2127842,2127938,2128034,2128130,2128226,2128322,2128418,2127523,2127619,2127715,2127811,2127907,2128003,2128099]),
|
|
|
new Uint32Array([2214753,6291456,2214785,6291456,6291456,2214817,2214849,2214881,2214913,2214945,2214977,2215009,2215041,2215073,2194369,6291456]),
|
|
|
new Uint32Array([2143969,2173793,2173825,2153473,2173857,2173889,2173921,2173953,2173985,2173761,2174017,2174049,2174081,2174113,2174145,2174177]),
|
|
|
new Uint32Array([2176385,6291456,2176417,6291456,2176449,6291456,2176481,6291456,2176513,6291456,2176545,6291456,2176577,6291456,2176609,6291456]),
|
|
|
new Uint32Array([2209121,2209153,2209185,2209217,2209249,2209281,2209313,2209345,2209377,2209409,2209441,2209473,2207265,2209505,2209537,2209569]),
|
|
|
new Uint32Array([2134145,2097153,2134241,2105953,2132705,2130977,2160065,2131297,2162049,2133089,2160577,2133857,2230817,2220769,2230849,2230881]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,2186369,0,2186401,0,2186433,0,2186465]),
|
|
|
new Uint32Array([2131586,2132450,2135970,2135778,2161602,2136162,2163650,2161794,2135586,2163714,2137186,2131810,2160290,2135170,2097506,2159554]),
|
|
|
new Uint32Array([2134145,2097153,2134241,2105953,2132705,2130977,2160065,2131297,2162049,2133089,2160577,2133857,0,0,0,0]),
|
|
|
new Uint32Array([2116513,2116609,2116705,2116801,2116897,2116993,2117089,2117185,2117281,2117377,2117473,2117569,2117665,2117761,2117857,2117953]),
|
|
|
new Uint32Array([2100737,2098337,2101441,2101569,2101697,2101825,2101953,2102081,2102209,2100802,2101154,2101282,2101410,2101538,2101666,2101794]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2166786,2166850,0,0,0,0]),
|
|
|
new Uint32Array([6291456,6291456,6291456,0,6291456,6291456,6291456,6291456,6291456,2109955,6291456,6291456,0,0,0,0]),
|
|
|
new Uint32Array([18874368,18874368,18874368,18874368,18874368,18874368,18874368,18874368,18874368,18874368,18874368,18874368,18874368,18874368,18874368,18874368]),
|
|
|
new Uint32Array([2130979,2131075,2131075,2131171,2131267,2131363,2131459,2131555,2131651,2131651,2131747,2131843,2131939,2132035,2132131,2132227]),
|
|
|
new Uint32Array([0,2177793,6291456,2177825,6291456,2177857,6291456,2177889,6291456,2177921,6291456,2177953,6291456,2177985,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([6291456,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2113345,0,2098209,2111137,2105505,2098241,2108353,2108417,2105825,2111713,2100897,2111905,2105473,2105569,2105601,2112289]),
|
|
|
new Uint32Array([2136643,2136739,2136835,2136931,2137027,2137123,2137219,2137315,2137411,2137507,2137603,2137699,2137795,2137891,2137987,2138083]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0]),
|
|
|
new Uint32Array([2174433,6291456,2174465,6291456,2174497,6291456,2174529,6291456,2174561,6291456,2174593,6291456,2174625,6291456,2174657,6291456]),
|
|
|
new Uint32Array([6291456,0,0,0,0,0,0,23068672,0,0,0,0,0,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2235585,2235617,2235649,2235681,2235713,2235745,2235777,2235809,2235841,2235874,2235937,2235969,2236001,2236033,2207905,2236066]),
|
|
|
new Uint32Array([0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2198369,2198401,2198433,2198465,0,2198497,2198529,2198561,2198593,2198625,2198657,2198689,2198721,2198753,2198785,2198817]),
|
|
|
new Uint32Array([2105473,2105569,2105601,2112289,2108193,2112481,2112577,2098177,2098305,2108321,2108289,2100865,2113153,2108481,2113345,2113441]),
|
|
|
new Uint32Array([10496547,10496643,2105505,2149698,6291456,10496739,10496835,2170273,6291456,2149762,2105825,2111713,2111713,2111713,2111713,2168673]),
|
|
|
new Uint32Array([6291456,2143490,2143490,2143490,2171649,6291456,2171681,2171713,2171745,6291456,2171777,6291456,2171809,6291456,2171841,6291456]),
|
|
|
new Uint32Array([2159106,2159106,2159170,2159170,2159234,2159234,2159298,2159298,2159298,2159362,2159362,2159362,2106401,2106401,2106401,2106401]),
|
|
|
new Uint32Array([2105601,2112289,2108193,2112481,2112577,2098177,2098305,2108321,2108289,2100865,2113153,2108481,2113345,2113441,2098209,2111137]),
|
|
|
new Uint32Array([6291456,0,6291456,6291456,6291456,6291456,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,0,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2135170,2097506,2130691,2130787,2130883,2163970,2164034,2164098,2164162,2164226,2164290,2164354,2164418,2164482,2164546,2133122]),
|
|
|
new Uint32Array([6291456,6291456,4271169,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,2174273]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2206753,2206785,2195425,2206817,2206849,2206881,2206913,2197121,2197121,2206945,2117857,2206977,2207009,2207041,2207073,2207105]),
|
|
|
new Uint32Array([2245313,2245345,2245377,2245409,2245442,2245506,2245570,2245633,2245665,2245697,2245729,2245762,2245825,2245858,2245921,2245953]),
|
|
|
new Uint32Array([2210113,2195489,2210145,2210177,2210209,2210241,2210273,2210305,2210337,2210369,2210401,2210433,2210465,2210497,2210529,2210561]),
|
|
|
new Uint32Array([0,2113729,2197313,2197345,2113825,2197377,2197409,2113921,2197441,2114017,2197473,2197505,2197537,2197569,2197601,2197633]),
|
|
|
new Uint32Array([2219105,2219137,2195201,2247042,2247105,2247137,2247169,2247201,2247234,2247298,2247361,2247393,2247425,2247458,2247521,2219169]),
|
|
|
new Uint32Array([2218433,2241249,2241281,2241313,2241345,2241378,2241441,2241474,2209665,2241538,2241601,2241634,2241698,2241762,2241825,2241857]),
|
|
|
new Uint32Array([2108515,2108611,2100740,2108707,2108803,2108899,2108995,2109091,2109187,2109283,2109379,2109475,2109571,2109667,2109763,2100738]),
|
|
|
new Uint32Array([2102788,2102916,2103044,2120515,2103172,2120611,2120707,2098373,2103300,2120803,2120899,2120995,2103428,2103556,2121091,2121187]),
|
|
|
new Uint32Array([2158082,2158146,0,2158210,2158274,0,2158338,2158402,2158466,2129922,2158530,2158594,2158658,2158722,2158786,2158850]),
|
|
|
new Uint32Array([10499619,10499715,10499811,10499907,10500003,10500099,10500195,10500291,10500387,10500483,10500579,10500675,10500771,10500867,10500963,10501059]),
|
|
|
new Uint32Array([2208161,2208193,2208225,2208257,2194401,2208289,2208321,2208353,2208385,2208417,2208449,2208481,2208513,2208545,2208577,2208609]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,10538050,10538114,10538178,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2226402,2226466,2226530,2226594,2226658,2226722,2226786,2226850,2226914,2226978,2227042,2227106,2227170,2227234,2227298,2227362]),
|
|
|
new Uint32Array([23068672,6291456,6291456,6291456,6291456,2144066,2144130,2144194,2144258,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,23068672,23068672,23068672,6291456,23068672,23068672]),
|
|
|
new Uint32Array([6291456,23068672,23068672,23068672,0,23068672,23068672,0,0,0,0,0,23068672,23068672,23068672,23068672]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2124674,2124770,2123875,2123971,2124067,2124163,2124259,2124355,2124451,2124547,2124643,2124739,2124835,2124931,2125027,2125123]),
|
|
|
new Uint32Array([2168065,6291456,2168097,6291456,2168129,6291456,2168161,6291456,2168193,6291456,2168225,6291456,2168257,6291456,2168289,6291456]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,0,0,0,0]),
|
|
|
new Uint32Array([23068672,23068672,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,2100610,2100611,6291456,2107842,2107843,6291456,6291456,6291456,6291456,10537922,6291456,10537986,6291456]),
|
|
|
new Uint32Array([2174849,2174881,2174913,2174945,2174977,2175009,2175041,2175073,2175105,2175137,2175169,2175201,2175233,2175265,2175297,2175329]),
|
|
|
new Uint32Array([2154562,2154626,2154690,2154754,2141858,2154818,2154882,2127298,2154946,2127298,2155010,2155074,2155138,2155202,2155266,2155202]),
|
|
|
new Uint32Array([2240705,2218369,2240737,2240770,2240833,2240865,2240898,2240962,2241025,2241057,2241089,2241121,2241153,2241153,2241185,2241217]),
|
|
|
new Uint32Array([2118049,2105345,2118241,2105441,2118433,2118529,2118625,2118721,2118817,2200225,2200257,2191777,2200289,2200321,2200353,2200385]),
|
|
|
new Uint32Array([2155330,2155394,0,2155458,2155522,2155586,2105732,0,2155650,2155714,2155778,2125314,2155842,2155906,2126274,2155970]),
|
|
|
new Uint32Array([23068672,23068672,23068672,23068672,23068672,6291456,6291456,23068672,23068672,6291456,23068672,23068672,23068672,23068672,6291456,6291456]),
|
|
|
new Uint32Array([6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,6291456,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2222273,2197185,2221473,2221505,2221089,2222305,2200833,2099681,2104481,2222337,2099905,2120737,2222369,2103713,2100225,2098785]),
|
|
|
new Uint32Array([6291456,6291456,2116513,2116609,2116705,2116801,2199841,2199873,2199905,2199937,2190881,2199969,2200001,2200033,2200065,2190977]),
|
|
|
new Uint32Array([2139331,2139427,2139523,2139043,2133571,2132611,2139619,2139715,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2174113,2174145,2100897,2098177,2108289,2100865,2173601,2173633,2173985,2174113,2174145,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([23068672,23068672,18923778,23068672,23068672,23068672,23068672,18923842,23068672,23068672,23068672,23068672,18923906,23068672,23068672,23068672]),
|
|
|
new Uint32Array([2134145,2097153,2134241,0,2132705,2130977,2160065,2131297,0,2133089,0,2133857,0,0,0,0]),
|
|
|
new Uint32Array([0,0,0,0,0,0,0,0,0,0,0,6291456,6291456,6291456,6291456,6291456]),
|
|
|
new Uint32Array([2177537,6291456,2177569,6291456,2177601,6291456,2177633,6291456,2177665,6291456,2177697,6291456,2177729,6291456,2177761,6291456]),
|
|
|
new Uint32Array([2097729,2106017,2106017,2106017,2106017,2131297,2131297,2131297,2131297,2106081,2106081,2162049,2162049,2105953,2105953,2162337]),
|
|
|
new Uint32Array([6291456,6291456,23068672,23068672,23068672,6291456,6291456,0,0,0,0,0,0,0,0,0]),
|
|
|
new Uint32Array([2098241,2108353,2170209,2105825,2111713,2100897,2111905,2105473,2105569,2105601,2112289,6291456,2108193,2172417,2112481,2098177]),
|
|
|
new Uint32Array([6291456,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,23068672,6291456,6291456]),
|
|
|
];
|
|
|
var blockIdxes = new Uint16Array([595,595,551,224,155,396,322,3,127,127,317,434,96,394,88,88,681,111,339,342,315,290,454,211,620,228,430,68,359,582,120,655,219,221,599,148,106,88,88,88,88,88,88,489,88,418,615,88,216,216,216,216,202,216,216,497,189,590,213,88,661,445,648,87,685,354,184,88,88,88,628,390,147,11,139,699,642,250,605,288,115,2,427,334,135,59,550,88,236,558,216,74,374,88,116,440,623,587,88,88,295,216,88,676,88,88,88,88,88,156,690,88,437,32,88,216,619,88,88,88,88,88,69,286,88,88,295,183,88,63,173,647,88,152,127,127,127,127,88,440,127,127,13,216,242,88,88,677,216,567,343,88,421,426,73,444,52,122,170,631,17,426,73,100,162,188,623,81,506,378,73,108,275,644,170,218,85,426,73,108,415,410,170,679,398,113,608,57,248,386,623,116,485,118,73,565,145,407,170,598,58,118,73,370,145,457,170,33,58,118,88,578,412,217,170,338,613,126,88,99,226,258,623,600,550,88,88,27,143,631,127,127,312,49,142,335,369,514,127,127,175,26,88,387,151,364,158,525,37,66,696,198,95,116,127,127,88,88,295,393,88,268,436,195,471,351,127,127,239,88,88,140,88,88,88,88,88,647,550,88,88,88,88,88,88,88,88,88,88,88,88,88,328,355,88,88,328,88,88,368,658,71,88,88,88,658,88,88,88,496,88,296,88,691,88,88,88,88,88,511,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,550,296,88,88,88,88,88,105,432,329,88,701,88,38,432,384,88,88,88,572,216,543,691,691,283,691,88,88,88,88,88,679,88,88,9,88,88,88,88,534,88,647,682,682,659,88,437,440,88,88,631,88,691,528,88,88,88,240,88,88,88,137,216,123,691,691,437,196,127,127,127,127,484,88,88,466,247,88,295,492,499,88,703,88,88,88,69,201,88,88,466,416,450,88,88,88,127,127,127,127,679,112,110,540,88,88,119,702,597,165,695,404,88,622,467,172,216,216,216,461,478,287,298,562,375,215,292,164,272,383,353,311,18,274,468,233,577,166,231,43,419,633,54,533,132,349,22,271,406,76,475,40,340,23,465,684,674,518,564,1,91,75,146,647,127,216,216,255,654,618,476,488,150,669,259,259,639,88,88,88,88,88,88,88,88,88,474,316,88,88,6,88,88,88,88,88,88,88,88,88,88,88,302,88,88,88,88,88,88,88,88,88,88,88,88,116,88,88,168,127,116,127,637,204,230,556,92,325,653,41,299,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,516,88,88,88,88,88,88,84,88,88,88,88,88,549,88,88,88,88,88,88,88,88,88,583,88,314,88,450,73,621,72,127,273,178,413,88,88,647,229,510,438,348,417,199,356,508,34,346,88,88,452,88,88,88,381,559,88,168,200,200,200,200,216,216,88,88,88,88,101,127,127,127,88,109,88,88,88,88,88,385,244,470,48,65,53,7,379,505,160,279,519,530,609,423,127,127,89,88,301,376,550,88,88,88,88,573,88,88,88,88,88,513,495,88,437,666,482,50,652,237,584,693,88,116,88,88,431,88,134,262,82,181,243,29,585,494,636,688,610,424,360,366,197,552,670,570,149,446,580,463,680,24,403,411,67,686,689,270,625,21,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,534,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,534,127,127,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,296,88,88,88,168,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,631,127,624,527,405,253,30,169,88,88,88,88,88,553,88,88,128,524,31,345,477,503,589,469,56,473,127,127,127,20,254,88,209,691,88,88,88,679,683,88,88,466,611,691,216,241,88,88,117,88,154,459,88,296,242,88,88,643,581,439,607,647,88,88,265,435,46,291,88,246,88,88,88,261,102,698,295,269,318,388,200,88,88,541,534,344,336,442,313,571,88,88,4,691,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,431,88,502,88,88,631,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,663,538,462,673,391,629,324,665,594,529,547,277,8,94,214,256,163,626,79,19,575,544,545,227,520,382,293,523,539,420,127,127,449,161,282,0,671,521,414,326,235,320,456,554,621,592,289,656,501,309,372,114,526,179,177,352,408,212,93,70,504,634,447,660,433,395,460,90,127,641,42,515,490,252,646,451,694,127,127,596,640,171,216,464,182,193,130,251,144,159,700,531,285,555,35,260,167,365,507,60,220,45,692,512,603,593,666,493,546,321,266,127,632,88,71,25,437,437,127,127,88,88,88,88,88,88,88,116,297,88,88,532,88,88,88,88,296,631,644,127,127,88,88,61,127,127,127,127,127,127,127,127,88,296,88,88,88,644,234,631,88,88,431,88,116,88,88,304,88,64,88,88,560,534,127,127,331,62,453,88,88,88,88,88,88,437,691,127,127,127,127,127,88,88,679,88,88,88,310,127,127,127,127,127,127,127,127,127,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,168,88,534,679,127,127,127,127,127,127,127,127,127,80,88,88,136,88,486,88,88,88,647,579,127,127,127,88,15,88,16,88,591,127,127,127,127,88,88,88,225,88,651,88,88,678,125,88,5,679,105,88,88,88,88,127,127,88,88,373,168,88,88,88,338,88,314,88,574,88,210,509,127,127,127,127,127,88,88,88,88,105,127,127,127,483,675,586,350,88,88,88,257,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,88,647,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,499,88,88,39,133,651,88,157,499,88,88,535,621,88,105,691,499,88,154,361,431,88,88,428,499,88,88,643,44,88,550,440,88,378,601,337,127,127,127,127,377,64,691,88,88,332,206,691,616,426,73,108,415,649,103,191,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,88,88,88,216,612,691,127,127,127,127,127,127,127,127,127,127,88,88,332,561,234,498,127,127,88,88,88,216,281,691,127,127,88,88,295,358,691,127,127,127,88,367,682,88,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,245,441,88,88,88,190,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,88,88,88,105,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,691,127,127,127,127,127,127,88,88,88,88,88,88,647,440,88,88,88,88,88,88,88,88,88,88,88,88,431,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,647,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,168,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,105,88,647,439,127,127,127,127,127,127,88,437,222,88,88,88,500,534,14,378,392,88,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,88,88,88,88,440,51,216,196,157,499,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,621,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,88,88,88,88,88,88,116,296,105,28,576,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,534,88,88,662,88,88,138,185,303,568,88,351,479,455,88,105,127,88,88,88,88,192,127,127,127,127,127,127,127,127,127,127,127,88,88,88,88,88,168,88,621,127,127,127,127,127,127,127,127,41,487,537,330,657,83,121,402,422,124,548,357,401,41,487,537,569,141,542,307,617,645,187,347,98,653,41,487,537,330,657,542,121,402,422,187,347,98,653,41,487,537,429,627,397,276,323,55,327,284,263,97,604,458,238,409,305,409,606,399,602,491,131,203,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,216,216,216,481,216,216,563,607,536,480,558,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,88,88,88,88,88,88,88,88,88,88,88,88,205,435,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,10,630,153,697,380,522,371,308,389,635,207,635,127,127,127,621,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,88,88,631,88,88,88,88,88,88,431,647,550,550,550,88,534,104,672,129,41,588,88,638,88,88,557,127,127,127,127,623,88,174,280,176,443,194,614,127,127,127,127,127,127,127,127,127,127,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,14,88,88,448,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,644,296,431,88,88,88,88,88,88,88,431,88,88,88,88,88,440,127,127,631,88,88,88,679,691,88,88,679,88,437,127,127,127,127,127,127,105,127,127,127,127,127,127,440,127,127,127,644,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,168,127,127,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,440,88,88,88,88,88,88,88,88,88,88,88,88,88,437,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,88,621,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,223,36,47,363,12,319,278,180,650,86,249,186,306,362,341,517,472,77,687,668,208,300,264,400,267,232,664,107,78,667,566,425,333,294,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127]);
|
|
|
var mappingStr = "صلى الله عليه وسلمجل جلالهキロメートルrad∕s2エスクードキログラムキロワットグラムトンクルゼイロサンチームパーセントピアストルファラッドブッシェルヘクタールマンションミリバールレントゲン′′′′1⁄10viii(10)(11)(12)(13)(14)(15)(16)(17)(18)(19)(20)∫∫∫∫(오전)(오후)アパートアルファアンペアイニングエーカーカラットカロリーキュリーギルダークローネサイクルシリングバーレルフィートポイントマイクロミクロンメガトンリットルルーブル株式会社kcalm∕s2c∕kgاكبرمحمدصلعمرسولریال1⁄41⁄23⁄4 ̈́ྲཱྀླཱྀ ̈͂ ̓̀ ̓́ ̓͂ ̔̀ ̔́ ̔͂ ̈̀‵‵‵a/ca/sc/oc/utelfax1⁄71⁄91⁄32⁄31⁄52⁄53⁄54⁄51⁄65⁄61⁄83⁄85⁄87⁄8xii0⁄3∮∮∮(1)(2)(3)(4)(5)(6)(7)(8)(9)(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p)(q)(r)(s)(t)(u)(v)(w)(x)(y)(z)::====(ᄀ)(ᄂ)(ᄃ)(ᄅ)(ᄆ)(ᄇ)(ᄉ)(ᄋ)(ᄌ)(ᄎ)(ᄏ)(ᄐ)(ᄑ)(ᄒ)(가)(나)(다)(라)(마)(바)(사)(아)(자)(차)(카)(타)(파)(하)(주)(一)(二)(三)(四)(五)(六)(七)(八)(九)(十)(月)(火)(水)(木)(金)(土)(日)(株)(有)(社)(名)(特)(財)(祝)(労)(代)(呼)(学)(監)(企)(資)(協)(祭)(休)(自)(至)pte10月11月12月ergltdアールインチウォンオンスオームカイリガロンガンマギニーケースコルナコーポセンチダースノットハイツパーツピクルフランペニヒヘルツペンスページベータボルトポンドホールホーンマイルマッハマルクヤードヤールユアンルピー10点11点12点13点14点15点16点17点18点19点20点21点22点23点24点hpabardm2dm3khzmhzghzthzmm2cm2km2mm3cm3km3kpampagpalogmilmolppmv∕ma∕m10日11日12日13日14日15日16日17日18日19日20日21日22日23日24日25日26日27日28日29日30日31日galffifflשּׁשּׂ ٌّ ٍّ َّ ُّ ِّ ّٰـَّـُّـِّتجمتحجتحمتخمتمجتمحتمخجمححميحمىسحجسجحسجىسمحسمجسممصححصممشحمشجيشمخشممضحىضخمطمحطممطميعجمعممعمىغممغميغمىفخمقمحقمملحملحيلحىلججلخملمحمحجمحيمجحمجممخممجخهمجهممنحمنحىنجمنجىنمينمىيممبخيتجيتجىتخيتخىتميتمىجميجحىجمىسخىصحيشحيضحيلجيلمييحييجييميمميقمينحيعميكمينجحمخيلجمكممجحيحجيمجيفميبحيسخينجيصلےقلے𝅘𝅥𝅮𝅘𝅥𝅯𝅘𝅥𝅰𝅘𝅥𝅱𝅘𝅥𝅲𝆹𝅥𝅮𝆺𝅥𝅮𝆹𝅥𝅯𝆺𝅥𝅯〔s〕ppv〔本〕〔三〕〔二〕〔安〕〔点〕〔打〕〔盗〕〔勝〕〔敗〕 ̄ ́ ̧ssi̇ijl·ʼndžljnjdz ̆ ̇ ̊ ̨ ̃ ̋ ιեւاٴوٴۇٴيٴक़ख़ग़ज़ड़ढ़फ़य़ড়ঢ়য়ਲ਼ਸ਼ਖ਼ਗ਼ਜ਼ਫ਼ଡ଼ଢ଼ําໍາຫນຫມགྷཌྷདྷབྷཛྷཀྵཱཱིུྲྀླྀྒྷྜྷྡྷྦྷྫྷྐྵaʾἀιἁιἂιἃιἄιἅιἆιἇιἠιἡιἢιἣιἤιἥιἦιἧιὠιὡιὢιὣιὤιὥιὦιὧιὰιαιάιᾶι ͂ὴιηιήιῆιὼιωιώιῶι ̳!! ̅???!!?rs°c°fnosmtmivix⫝̸ ゙ ゚よりコト333435참고주의363738394042444546474849503月4月5月6月7月8月9月hgevギガデシドルナノピコビルペソホンリラレムdaauovpciu平成昭和大正明治naμakakbmbgbpfnfμfμgmgμlmldlklfmnmμmpsnsμsmsnvμvkvpwnwμwmwkwkωmωbqcccddbgyhainkkktlnlxphprsrsvwbstմնմեմիվնմխיִײַשׁשׂאַאָאּבּגּדּהּוּזּטּיּךּכּלּמּנּסּףּפּצּקּרּתּוֹבֿכֿפֿאלئائەئوئۇئۆئۈئېئىئجئحئمئيبجبمبىبيتىتيثجثمثىثيخحضجضمطحظمغجفجفحفىفيقحقىقيكاكجكحكخكلكىكينخنىنيهجهىهييىذٰرٰىٰئرئزئنبزبنترتزتنثرثزثنمانرنزننيريزئخئهبهتهصخنههٰثهسهشهطىطيعىعيغىغيسىسيشىشيصىصيضىضيشخشرسرصرضراً ًـًـّ ْـْلآلألإ𝅗𝅥0,1,2,3,4,5,6,7,8,9,wzhvsdwcmcmddjほかココàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþāăąćĉċčďđēĕėęěĝğġģĥħĩīĭįĵķĺļľłńņňŋōŏőœŕŗřśŝşšţťŧũūŭůűųŵŷÿźżɓƃƅɔƈɖɗƌǝəɛƒɠɣɩɨƙɯɲɵơƣƥʀƨʃƭʈưʊʋƴƶʒƹƽǎǐǒǔǖǘǚǜǟǡǣǥǧǩǫǭǯǵƕƿǹǻǽǿȁȃȅȇȉȋȍȏȑȓȕȗșțȝȟƞȣȥȧȩȫȭȯȱȳⱥȼƚⱦɂƀʉʌɇɉɋɍɏɦɹɻʁʕͱͳʹͷ;ϳέίόύβγδεζθκλνξοπρστυφχψϊϋϗϙϛϝϟϡϣϥϧϩϫϭϯϸϻͻͼͽѐёђѓєѕіїјљњћќѝўџабвгдежзийклмнопрстуфхцчшщъыьэюяѡѣѥѧѩѫѭѯѱѳѵѷѹѻѽѿҁҋҍҏґғҕҗҙқҝҟҡңҥҧҩҫҭүұҳҵҷҹһҽҿӂӄӆӈӊӌӎӑӓӕӗәӛӝӟӡӣӥӧөӫӭӯӱӳӵӷӹӻӽӿԁԃԅԇԉԋԍԏԑԓԕԗԙԛԝԟԡԣԥԧԩԫԭԯաբգդզէըթժլծկհձղճյշոչպջռստրցփքօֆ་ⴧⴭნᏰᏱᏲᏳᏴᏵɐɑᴂɜᴖᴗᴝᴥɒɕɟɡɥɪᵻʝɭᶅʟɱɰɳɴɸʂƫᴜʐʑḁḃḅḇḉḋḍḏḑḓḕḗḙḛḝḟḡḣḥḧḩḫḭḯḱḳḵḷḹḻḽḿṁṃṅṇṉṋṍṏṑṓṕṗṙṛṝṟṡṣṥṧṩṫṭṯṱṳṵṷṹṻṽṿẁẃẅẇẉẋẍẏẑẓẕạảấầẩẫậắằẳẵặẹẻẽếềểễệỉịọỏốồổỗộớờởỡợụủứừửữựỳỵỷỹỻỽỿἐἑἒἓἔἕἰἱἲἳἴἵἶἷὀὁὂὃὄὅὑὓὕὗᾰᾱὲΐῐῑὶΰῠῡὺῥ`ὸ‐+−∑〈〉ⰰⰱⰲⰳⰴⰵⰶⰷⰸⰹⰺⰻⰼⰽⰾⰿⱀⱁⱂⱃⱄⱅⱆⱇⱈⱉⱊⱋⱌⱍⱎⱏⱐⱑⱒⱓⱔⱕⱖⱗⱘⱙⱚⱛⱜⱝⱞⱡɫᵽɽⱨⱪⱬⱳⱶȿɀⲁⲃⲅⲇⲉⲋⲍⲏⲑⲓⲕⲗⲙⲛⲝⲟⲡⲣⲥⲧⲩⲫⲭⲯⲱⲳⲵⲷⲹⲻⲽⲿⳁⳃⳅⳇⳉⳋⳍⳏⳑⳓⳕⳗⳙⳛⳝⳟⳡⳣⳬⳮⳳⵡ母龟丨丶丿乙亅亠人儿入冂冖冫几凵刀力勹匕匚匸卜卩厂厶又口囗士夂夊夕女子宀寸小尢尸屮山巛工己巾干幺广廴廾弋弓彐彡彳心戈戶手支攴文斗斤方无曰欠止歹殳毋比毛氏气爪父爻爿片牙牛犬玄玉瓜瓦甘生用田疋疒癶白皮皿目矛矢石示禸禾穴立竹米糸缶网羊羽老而耒耳聿肉臣臼舌舛舟艮色艸虍虫血行衣襾見角言谷豆豕豸貝赤走足身車辛辰辵邑酉釆里長門阜隶隹雨靑非面革韋韭音頁風飛食首香馬骨高髟鬥鬯鬲鬼魚鳥鹵鹿麥麻黃黍黑黹黽鼎鼓鼠鼻齊齒龍龜龠.〒卄卅ᄁᆪᆬᆭᄄᆰᆱᆲᆳᆴᆵᄚᄈᄡᄊ짜ᅢᅣᅤᅥᅦᅧᅨᅩᅪᅫᅬᅭᅮᅯᅰᅱᅲᅳᅴᅵᄔᄕᇇᇈᇌᇎᇓᇗᇙᄜᇝᇟᄝᄞᄠᄢᄣᄧᄩᄫᄬᄭᄮᄯᄲᄶᅀᅇᅌᇱᇲᅗᅘᅙᆄᆅᆈᆑᆒᆔᆞᆡ上中下甲丙丁天地問幼箏우秘男適優印注項写左右医宗夜テヌモヨヰヱヲꙁꙃꙅꙇꙉꙋꙍꙏꙑꙓꙕꙗꙙꙛꙝꙟꙡꙣꙥꙧꙩꙫꙭꚁꚃꚅꚇꚉꚋꚍꚏꚑꚓꚕꚗꚙꚛꜣꜥꜧꜩꜫꜭꜯꜳꜵꜷꜹꜻꜽꜿꝁꝃꝅꝇꝉꝋꝍꝏꝑꝓꝕꝗꝙꝛꝝꝟꝡꝣꝥꝧꝩꝫꝭꝯꝺꝼᵹꝿꞁꞃꞅꞇꞌꞑꞓꞗꞙꞛꞝꞟꞡꞣꞥꞧꞩɬʞʇꭓꞵꞷꬷꭒᎠᎡᎢᎣᎤᎥᎦᎧᎨᎩᎪᎫᎬᎭᎮᎯᎰᎱᎲᎳᎴᎵᎶᎷᎸᎹᎺᎻᎼᎽᎾᎿᏀᏁᏂᏃᏄᏅᏆᏇᏈᏉᏊᏋᏌᏍᏎᏏᏐᏑᏒᏓᏔᏕᏖᏗᏘᏙᏚᏛᏜᏝᏞᏟᏠᏡᏢᏣᏤᏥᏦᏧᏨᏩᏪᏫᏬᏭᏮᏯ豈更賈滑串句契喇奈懶癩羅蘿螺裸邏樂洛烙珞落酪駱亂卵欄爛蘭鸞嵐濫藍襤拉臘蠟廊朗浪狼郎來冷勞擄櫓爐盧蘆虜路露魯鷺碌祿綠菉錄論壟弄籠聾牢磊賂雷壘屢樓淚漏累縷陋勒肋凜凌稜綾菱陵讀拏諾丹寧怒率異北磻便復不泌數索參塞省葉說殺沈拾若掠略亮兩凉梁糧良諒量勵呂廬旅濾礪閭驪麗黎曆歷轢年憐戀撚漣煉璉秊練聯輦蓮連鍊列劣咽烈裂廉念捻殮簾獵令囹嶺怜玲瑩羚聆鈴零靈領例禮醴隸惡了僚寮尿料燎療蓼遼暈阮劉杻柳流溜琉留硫紐類戮陸倫崙淪輪律慄栗隆利吏履易李梨泥理痢罹裏裡離匿溺吝燐璘藺隣鱗麟林淋臨笠粒狀炙識什茶刺切度拓糖宅洞暴輻降廓兀嗀塚晴凞猪益礼神祥福靖精蘒諸逸都飯飼館鶴郞隷侮僧免勉勤卑喝嘆器塀墨層悔慨憎懲敏既暑梅海渚漢煮爫琢碑祉祈祐祖禍禎穀突節縉繁署者臭艹著褐視謁謹賓贈辶難響頻恵𤋮舘並况全侀充冀勇勺啕喙嗢墳奄奔婢嬨廒廙彩徭惘慎愈慠戴揄搜摒敖望杖滛滋瀞瞧爵犯瑱甆画瘝瘟盛直睊着磌窱类絛缾荒華蝹襁覆調請諭變輸遲醙鉶陼韛頋鬒𢡊𢡄𣏕㮝䀘䀹𥉉𥳐𧻓齃龎עםٱٻپڀٺٿٹڤڦڄڃچڇڍڌڎڈژڑکگڳڱںڻۀہھۓڭۋۅۉ、〖〗—–_{}【】《》「」『』[]#&*-<>\\$%@ءؤة\"'^|~⦅⦆・ゥャ¢£¬¦¥₩│←↑→↓■○𐐨𐐩𐐪𐐫𐐬𐐭𐐮𐐯𐐰𐐱𐐲𐐳𐐴𐐵𐐶𐐷𐐸𐐹𐐺𐐻𐐼𐐽𐐾𐐿𐑀𐑁𐑂𐑃𐑄𐑅𐑆𐑇𐑈𐑉𐑊𐑋𐑌𐑍𐑎𐑏𐳀𐳁𐳂𐳃𐳄𐳅𐳆𐳇𐳈𐳉𐳊𐳋𐳌𐳍𐳎𐳏𐳐𐳑𐳒𐳓𐳔𐳕𐳖𐳗𐳘𐳙𐳚𐳛𐳜𐳝𐳞𐳟𐳠𐳡𐳢𐳣𐳤𐳥𐳦𐳧𐳨𐳩𐳪𐳫𐳬𐳭𐳮𐳯𐳰𐳱𐳲𑣀𑣁𑣂𑣃𑣄𑣅𑣆𑣇𑣈𑣉𑣊𑣋𑣌𑣍𑣎𑣏𑣐𑣑𑣒𑣓𑣔𑣕𑣖𑣗𑣘𑣙𑣚𑣛𑣜𑣝𑣞𑣟ıȷ∇∂ٮڡٯ字双多解交映無前後再新初終販声吹演投捕遊指禁空合満申割営得可丽丸乁𠄢你侻倂偺備像㒞𠘺兔兤具𠔜㒹內𠕋冗冤仌冬𩇟刃㓟刻剆剷㔕包匆卉博即卽卿𠨬灰及叟𠭣叫叱吆咞吸呈周咢哶唐啓啣善喫喳嗂圖圗噑噴壮城埴堍型堲報墬𡓤売壷夆夢奢𡚨𡛪姬娛娧姘婦㛮嬈嬾𡧈寃寘寳𡬘寿将㞁屠峀岍𡷤嵃𡷦嵮嵫嵼巡巢㠯巽帨帽幩㡢𢆃㡼庰庳庶𪎒𢌱舁弢㣇𣊸𦇚形彫㣣徚忍志忹悁㤺㤜𢛔惇慈慌慺憲憤憯懞戛扝抱拔捐𢬌挽拼捨掃揤𢯱搢揅掩㨮摩摾撝摷㩬敬𣀊旣書晉㬙㬈㫤冒冕最暜肭䏙朡杞杓𣏃㭉柺枅桒𣑭梎栟椔楂榣槪檨𣚣櫛㰘次𣢧歔㱎歲殟殻𣪍𡴋𣫺汎𣲼沿泍汧洖派浩浸涅𣴞洴港湮㴳滇𣻑淹潮𣽞𣾎濆瀹瀛㶖灊災灷炭𠔥煅𤉣熜爨牐𤘈犀犕𤜵𤠔獺王㺬玥㺸瑇瑜璅瓊㼛甤𤰶甾𤲒𢆟瘐𤾡𤾸𥁄㿼䀈𥃳𥃲𥄙𥄳眞真瞋䁆䂖𥐝硎䃣𥘦𥚚𥛅秫䄯穊穏𥥼𥪧䈂𥮫篆築䈧𥲀糒䊠糨糣紀𥾆絣䌁緇縂繅䌴𦈨𦉇䍙𦋙罺𦌾羕翺𦓚𦔣聠𦖨聰𣍟䏕育脃䐋脾媵𦞧𦞵𣎓𣎜舄辞䑫芑芋芝劳花芳芽苦𦬼茝荣莭茣莽菧荓菊菌菜𦰶𦵫𦳕䔫蓱蓳蔖𧏊蕤𦼬䕝䕡𦾱𧃒䕫虐虧虩蚩蚈蜎蛢蜨蝫螆蟡蠁䗹衠𧙧裗裞䘵裺㒻𧢮𧥦䚾䛇誠𧲨貫賁贛起𧼯𠠄跋趼跰𠣞軔𨗒𨗭邔郱鄑𨜮鄛鈸鋗鋘鉼鏹鐕𨯺開䦕閷𨵷䧦雃嶲霣𩅅𩈚䩮䩶韠𩐊䪲𩒖頩𩖶飢䬳餩馧駂駾䯎𩬰鱀鳽䳎䳭鵧𪃎䳸𪄅𪈎𪊑䵖黾鼅鼏鼖𪘀";
|
|
|
|
|
|
function mapChar(codePoint) {
|
|
|
if (codePoint >= 0x30000) {
|
|
|
// High planes are special cased.
|
|
|
if (codePoint >= 0xE0100 && codePoint <= 0xE01EF)
|
|
|
return 18874368;
|
|
|
return 0;
|
|
|
}
|
|
|
return blocks[blockIdxes[codePoint >> 4]][codePoint & 15];
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
mapStr: mappingStr,
|
|
|
mapChar: mapChar
|
|
|
};
|
|
|
}));
|
|
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
|
/* istanbul ignore next */
|
|
|
(function (root, factory) {
|
|
|
if (typeof define === 'function' && define.amd) {
|
|
|
define(['punycode', './idna-map'], function (punycode, idna_map) {
|
|
|
return factory(punycode, idna_map);
|
|
|
});
|
|
|
} else if (typeof exports === 'object') {
|
|
|
module.exports = factory(require('punycode'), require('./idna-map'));
|
|
|
} else {
|
|
|
root.uts46 = factory(root.punycode, root.idna_map);
|
|
|
}
|
|
|
}(this, function (punycode, idna_map) {
|
|
|
|
|
|
function mapLabel(label, useStd3ASCII, transitional) {
|
|
|
var mapped = [];
|
|
|
for (var ch of label) {
|
|
|
var cp = ch.codePointAt(0);
|
|
|
var composite = idna_map.mapChar(cp);
|
|
|
var flags = (composite >> 23);
|
|
|
var kind = (composite >> 21) & 3;
|
|
|
var index = (composite >> 5) & 0xffff;
|
|
|
var length = composite & 0x1f;
|
|
|
var value = idna_map.mapStr.substr(index, length);
|
|
|
if (kind == 0 || (useStd3ASCII && (flags & 1))) {
|
|
|
throw new Error("Illegal char " + ch);
|
|
|
} else if (kind == 1) {
|
|
|
mapped.push(value);
|
|
|
} else if (kind == 2) {
|
|
|
mapped.push(transitional ? value : ch);
|
|
|
} else if (kind == 3) {
|
|
|
mapped.push(ch);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
var newLabel = mapped.join("").normalize("NFC");
|
|
|
return newLabel;
|
|
|
}
|
|
|
|
|
|
function process(domain, transitional, useStd3ASCII) {
|
|
|
if (useStd3ASCII === undefined)
|
|
|
useStd3ASCII = false;
|
|
|
var mappedIDNA = mapLabel(domain, useStd3ASCII, transitional);
|
|
|
|
|
|
// Step 3. Break
|
|
|
var labels = mappedIDNA.split(".");
|
|
|
|
|
|
// Step 4. Convert/Validate
|
|
|
labels = labels.map(function (label) {
|
|
|
if (label.startsWith("xn--")) {
|
|
|
label = punycode.decode(label.substring(4));
|
|
|
validateLabel(label, useStd3ASCII, false);
|
|
|
} else {
|
|
|
validateLabel(label, useStd3ASCII, transitional);
|
|
|
}
|
|
|
return label;
|
|
|
});
|
|
|
|
|
|
return labels.join(".");
|
|
|
}
|
|
|
|
|
|
function validateLabel(label, useStd3ASCII, transitional) {
|
|
|
// 2. The label must not contain a U+002D HYPHEN-MINUS character in both the
|
|
|
// third position and fourth positions.
|
|
|
if (label[2] == '-' && label[3] == '-')
|
|
|
throw new Error("Failed to validate " + label);
|
|
|
|
|
|
// 3. The label must neither begin nor end with a U+002D HYPHEN-MINUS
|
|
|
// character.
|
|
|
if (label.startsWith('-') || label.endsWith('-'))
|
|
|
throw new Error("Failed to validate " + label);
|
|
|
|
|
|
// 4. The label must not contain a U+002E ( . ) FULL STOP.
|
|
|
if (label.includes('.'))
|
|
|
throw new Error("Failed to validate " + label);
|
|
|
|
|
|
if (mapLabel(label, useStd3ASCII, transitional) != label)
|
|
|
throw new Error("Failed to validate " + label);
|
|
|
|
|
|
// 5. The label must not begin with a combining mark, that is:
|
|
|
// General_Category=Mark.
|
|
|
var ch = label.codePointAt(0);
|
|
|
if (idna_map.mapChar(ch) & (0x2 << 23))
|
|
|
throw new Error("Label contains illegal character: " + ch);
|
|
|
}
|
|
|
|
|
|
function toAscii(domain, options) {
|
|
|
if (options === undefined)
|
|
|
options = { };
|
|
|
var transitional = 'transitional' in options ? options.transitional : true;
|
|
|
var useStd3ASCII = 'useStd3ASCII' in options ? options.useStd3ASCII : false;
|
|
|
var labels = process(domain, transitional, useStd3ASCII).split('.');
|
|
|
return labels.map(punycode.toASCII).join('.');
|
|
|
}
|
|
|
function toUnicode(domain, options) {
|
|
|
if (options === undefined)
|
|
|
options = { };
|
|
|
var useStd3ASCII = 'useStd3ASCII' in options ? options.useStd3ASCII : false;
|
|
|
return process(domain, false, useStd3ASCII);
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
toUnicode: toUnicode,
|
|
|
toAscii: toAscii,
|
|
|
};
|
|
|
}));
|
|
|
|
|
|
},{"./idna-map":7,"punycode":5}],9:[function(require,module,exports){
|
|
|
(function (process,global){
|
|
|
/**
|
|
|
* [js-sha3]{@link https://github.com/emn178/js-sha3}
|
|
|
*
|
|
|
* @version 0.5.7
|
|
|
* @author Chen, Yi-Cyuan [emn178@gmail.com]
|
|
|
* @copyright Chen, Yi-Cyuan 2015-2016
|
|
|
* @license MIT
|
|
|
*/
|
|
|
/*jslint bitwise: true */
|
|
|
(function () {
|
|
|
'use strict';
|
|
|
|
|
|
var root = typeof window === 'object' ? window : {};
|
|
|
var NODE_JS = !root.JS_SHA3_NO_NODE_JS && typeof process === 'object' && process.versions && process.versions.node;
|
|
|
if (NODE_JS) {
|
|
|
root = global;
|
|
|
}
|
|
|
var COMMON_JS = !root.JS_SHA3_NO_COMMON_JS && typeof module === 'object' && module.exports;
|
|
|
var HEX_CHARS = '0123456789abcdef'.split('');
|
|
|
var SHAKE_PADDING = [31, 7936, 2031616, 520093696];
|
|
|
var KECCAK_PADDING = [1, 256, 65536, 16777216];
|
|
|
var PADDING = [6, 1536, 393216, 100663296];
|
|
|
var SHIFT = [0, 8, 16, 24];
|
|
|
var RC = [1, 0, 32898, 0, 32906, 2147483648, 2147516416, 2147483648, 32907, 0, 2147483649,
|
|
|
0, 2147516545, 2147483648, 32777, 2147483648, 138, 0, 136, 0, 2147516425, 0,
|
|
|
2147483658, 0, 2147516555, 0, 139, 2147483648, 32905, 2147483648, 32771,
|
|
|
2147483648, 32770, 2147483648, 128, 2147483648, 32778, 0, 2147483658, 2147483648,
|
|
|
2147516545, 2147483648, 32896, 2147483648, 2147483649, 0, 2147516424, 2147483648];
|
|
|
var BITS = [224, 256, 384, 512];
|
|
|
var SHAKE_BITS = [128, 256];
|
|
|
var OUTPUT_TYPES = ['hex', 'buffer', 'arrayBuffer', 'array'];
|
|
|
|
|
|
var createOutputMethod = function (bits, padding, outputType) {
|
|
|
return function (message) {
|
|
|
return new Keccak(bits, padding, bits).update(message)[outputType]();
|
|
|
};
|
|
|
};
|
|
|
|
|
|
var createShakeOutputMethod = function (bits, padding, outputType) {
|
|
|
return function (message, outputBits) {
|
|
|
return new Keccak(bits, padding, outputBits).update(message)[outputType]();
|
|
|
};
|
|
|
};
|
|
|
|
|
|
var createMethod = function (bits, padding) {
|
|
|
var method = createOutputMethod(bits, padding, 'hex');
|
|
|
method.create = function () {
|
|
|
return new Keccak(bits, padding, bits);
|
|
|
};
|
|
|
method.update = function (message) {
|
|
|
return method.create().update(message);
|
|
|
};
|
|
|
for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
|
|
|
var type = OUTPUT_TYPES[i];
|
|
|
method[type] = createOutputMethod(bits, padding, type);
|
|
|
}
|
|
|
return method;
|
|
|
};
|
|
|
|
|
|
var createShakeMethod = function (bits, padding) {
|
|
|
var method = createShakeOutputMethod(bits, padding, 'hex');
|
|
|
method.create = function (outputBits) {
|
|
|
return new Keccak(bits, padding, outputBits);
|
|
|
};
|
|
|
method.update = function (message, outputBits) {
|
|
|
return method.create(outputBits).update(message);
|
|
|
};
|
|
|
for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
|
|
|
var type = OUTPUT_TYPES[i];
|
|
|
method[type] = createShakeOutputMethod(bits, padding, type);
|
|
|
}
|
|
|
return method;
|
|
|
};
|
|
|
|
|
|
var algorithms = [
|
|
|
{name: 'keccak', padding: KECCAK_PADDING, bits: BITS, createMethod: createMethod},
|
|
|
{name: 'sha3', padding: PADDING, bits: BITS, createMethod: createMethod},
|
|
|
{name: 'shake', padding: SHAKE_PADDING, bits: SHAKE_BITS, createMethod: createShakeMethod}
|
|
|
];
|
|
|
|
|
|
var methods = {}, methodNames = [];
|
|
|
|
|
|
for (var i = 0; i < algorithms.length; ++i) {
|
|
|
var algorithm = algorithms[i];
|
|
|
var bits = algorithm.bits;
|
|
|
for (var j = 0; j < bits.length; ++j) {
|
|
|
var methodName = algorithm.name +'_' + bits[j];
|
|
|
methodNames.push(methodName);
|
|
|
methods[methodName] = algorithm.createMethod(bits[j], algorithm.padding);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function Keccak(bits, padding, outputBits) {
|
|
|
this.blocks = [];
|
|
|
this.s = [];
|
|
|
this.padding = padding;
|
|
|
this.outputBits = outputBits;
|
|
|
this.reset = true;
|
|
|
this.block = 0;
|
|
|
this.start = 0;
|
|
|
this.blockCount = (1600 - (bits << 1)) >> 5;
|
|
|
this.byteCount = this.blockCount << 2;
|
|
|
this.outputBlocks = outputBits >> 5;
|
|
|
this.extraBytes = (outputBits & 31) >> 3;
|
|
|
|
|
|
for (var i = 0; i < 50; ++i) {
|
|
|
this.s[i] = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Keccak.prototype.update = function (message) {
|
|
|
var notString = typeof message !== 'string';
|
|
|
if (notString && message.constructor === ArrayBuffer) {
|
|
|
message = new Uint8Array(message);
|
|
|
}
|
|
|
var length = message.length, blocks = this.blocks, byteCount = this.byteCount,
|
|
|
blockCount = this.blockCount, index = 0, s = this.s, i, code;
|
|
|
|
|
|
while (index < length) {
|
|
|
if (this.reset) {
|
|
|
this.reset = false;
|
|
|
blocks[0] = this.block;
|
|
|
for (i = 1; i < blockCount + 1; ++i) {
|
|
|
blocks[i] = 0;
|
|
|
}
|
|
|
}
|
|
|
if (notString) {
|
|
|
for (i = this.start; index < length && i < byteCount; ++index) {
|
|
|
blocks[i >> 2] |= message[index] << SHIFT[i++ & 3];
|
|
|
}
|
|
|
} else {
|
|
|
for (i = this.start; index < length && i < byteCount; ++index) {
|
|
|
code = message.charCodeAt(index);
|
|
|
if (code < 0x80) {
|
|
|
blocks[i >> 2] |= code << SHIFT[i++ & 3];
|
|
|
} else if (code < 0x800) {
|
|
|
blocks[i >> 2] |= (0xc0 | (code >> 6)) << SHIFT[i++ & 3];
|
|
|
blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
|
|
|
} else if (code < 0xd800 || code >= 0xe000) {
|
|
|
blocks[i >> 2] |= (0xe0 | (code >> 12)) << SHIFT[i++ & 3];
|
|
|
blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];
|
|
|
blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
|
|
|
} else {
|
|
|
code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff));
|
|
|
blocks[i >> 2] |= (0xf0 | (code >> 18)) << SHIFT[i++ & 3];
|
|
|
blocks[i >> 2] |= (0x80 | ((code >> 12) & 0x3f)) << SHIFT[i++ & 3];
|
|
|
blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];
|
|
|
blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
this.lastByteIndex = i;
|
|
|
if (i >= byteCount) {
|
|
|
this.start = i - byteCount;
|
|
|
this.block = blocks[blockCount];
|
|
|
for (i = 0; i < blockCount; ++i) {
|
|
|
s[i] ^= blocks[i];
|
|
|
}
|
|
|
f(s);
|
|
|
this.reset = true;
|
|
|
} else {
|
|
|
this.start = i;
|
|
|
}
|
|
|
}
|
|
|
return this;
|
|
|
};
|
|
|
|
|
|
Keccak.prototype.finalize = function () {
|
|
|
var blocks = this.blocks, i = this.lastByteIndex, blockCount = this.blockCount, s = this.s;
|
|
|
blocks[i >> 2] |= this.padding[i & 3];
|
|
|
if (this.lastByteIndex === this.byteCount) {
|
|
|
blocks[0] = blocks[blockCount];
|
|
|
for (i = 1; i < blockCount + 1; ++i) {
|
|
|
blocks[i] = 0;
|
|
|
}
|
|
|
}
|
|
|
blocks[blockCount - 1] |= 0x80000000;
|
|
|
for (i = 0; i < blockCount; ++i) {
|
|
|
s[i] ^= blocks[i];
|
|
|
}
|
|
|
f(s);
|
|
|
};
|
|
|
|
|
|
Keccak.prototype.toString = Keccak.prototype.hex = function () {
|
|
|
this.finalize();
|
|
|
|
|
|
var blockCount = this.blockCount, s = this.s, outputBlocks = this.outputBlocks,
|
|
|
extraBytes = this.extraBytes, i = 0, j = 0;
|
|
|
var hex = '', block;
|
|
|
while (j < outputBlocks) {
|
|
|
for (i = 0; i < blockCount && j < outputBlocks; ++i, ++j) {
|
|
|
block = s[i];
|
|
|
hex += HEX_CHARS[(block >> 4) & 0x0F] + HEX_CHARS[block & 0x0F] +
|
|
|
HEX_CHARS[(block >> 12) & 0x0F] + HEX_CHARS[(block >> 8) & 0x0F] +
|
|
|
HEX_CHARS[(block >> 20) & 0x0F] + HEX_CHARS[(block >> 16) & 0x0F] +
|
|
|
HEX_CHARS[(block >> 28) & 0x0F] + HEX_CHARS[(block >> 24) & 0x0F];
|
|
|
}
|
|
|
if (j % blockCount === 0) {
|
|
|
f(s);
|
|
|
i = 0;
|
|
|
}
|
|
|
}
|
|
|
if (extraBytes) {
|
|
|
block = s[i];
|
|
|
if (extraBytes > 0) {
|
|
|
hex += HEX_CHARS[(block >> 4) & 0x0F] + HEX_CHARS[block & 0x0F];
|
|
|
}
|
|
|
if (extraBytes > 1) {
|
|
|
hex += HEX_CHARS[(block >> 12) & 0x0F] + HEX_CHARS[(block >> 8) & 0x0F];
|
|
|
}
|
|
|
if (extraBytes > 2) {
|
|
|
hex += HEX_CHARS[(block >> 20) & 0x0F] + HEX_CHARS[(block >> 16) & 0x0F];
|
|
|
}
|
|
|
}
|
|
|
return hex;
|
|
|
};
|
|
|
|
|
|
Keccak.prototype.arrayBuffer = function () {
|
|
|
this.finalize();
|
|
|
|
|
|
var blockCount = this.blockCount, s = this.s, outputBlocks = this.outputBlocks,
|
|
|
extraBytes = this.extraBytes, i = 0, j = 0;
|
|
|
var bytes = this.outputBits >> 3;
|
|
|
var buffer;
|
|
|
if (extraBytes) {
|
|
|
buffer = new ArrayBuffer((outputBlocks + 1) << 2);
|
|
|
} else {
|
|
|
buffer = new ArrayBuffer(bytes);
|
|
|
}
|
|
|
var array = new Uint32Array(buffer);
|
|
|
while (j < outputBlocks) {
|
|
|
for (i = 0; i < blockCount && j < outputBlocks; ++i, ++j) {
|
|
|
array[j] = s[i];
|
|
|
}
|
|
|
if (j % blockCount === 0) {
|
|
|
f(s);
|
|
|
}
|
|
|
}
|
|
|
if (extraBytes) {
|
|
|
array[i] = s[i];
|
|
|
buffer = buffer.slice(0, bytes);
|
|
|
}
|
|
|
return buffer;
|
|
|
};
|
|
|
|
|
|
Keccak.prototype.buffer = Keccak.prototype.arrayBuffer;
|
|
|
|
|
|
Keccak.prototype.digest = Keccak.prototype.array = function () {
|
|
|
this.finalize();
|
|
|
|
|
|
var blockCount = this.blockCount, s = this.s, outputBlocks = this.outputBlocks,
|
|
|
extraBytes = this.extraBytes, i = 0, j = 0;
|
|
|
var array = [], offset, block;
|
|
|
while (j < outputBlocks) {
|
|
|
for (i = 0; i < blockCount && j < outputBlocks; ++i, ++j) {
|
|
|
offset = j << 2;
|
|
|
block = s[i];
|
|
|
array[offset] = block & 0xFF;
|
|
|
array[offset + 1] = (block >> 8) & 0xFF;
|
|
|
array[offset + 2] = (block >> 16) & 0xFF;
|
|
|
array[offset + 3] = (block >> 24) & 0xFF;
|
|
|
}
|
|
|
if (j % blockCount === 0) {
|
|
|
f(s);
|
|
|
}
|
|
|
}
|
|
|
if (extraBytes) {
|
|
|
offset = j << 2;
|
|
|
block = s[i];
|
|
|
if (extraBytes > 0) {
|
|
|
array[offset] = block & 0xFF;
|
|
|
}
|
|
|
if (extraBytes > 1) {
|
|
|
array[offset + 1] = (block >> 8) & 0xFF;
|
|
|
}
|
|
|
if (extraBytes > 2) {
|
|
|
array[offset + 2] = (block >> 16) & 0xFF;
|
|
|
}
|
|
|
}
|
|
|
return array;
|
|
|
};
|
|
|
|
|
|
var f = function (s) {
|
|
|
var h, l, n, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9,
|
|
|
b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17,
|
|
|
b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33,
|
|
|
b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49;
|
|
|
for (n = 0; n < 48; n += 2) {
|
|
|
c0 = s[0] ^ s[10] ^ s[20] ^ s[30] ^ s[40];
|
|
|
c1 = s[1] ^ s[11] ^ s[21] ^ s[31] ^ s[41];
|
|
|
c2 = s[2] ^ s[12] ^ s[22] ^ s[32] ^ s[42];
|
|
|
c3 = s[3] ^ s[13] ^ s[23] ^ s[33] ^ s[43];
|
|
|
c4 = s[4] ^ s[14] ^ s[24] ^ s[34] ^ s[44];
|
|
|
c5 = s[5] ^ s[15] ^ s[25] ^ s[35] ^ s[45];
|
|
|
c6 = s[6] ^ s[16] ^ s[26] ^ s[36] ^ s[46];
|
|
|
c7 = s[7] ^ s[17] ^ s[27] ^ s[37] ^ s[47];
|
|
|
c8 = s[8] ^ s[18] ^ s[28] ^ s[38] ^ s[48];
|
|
|
c9 = s[9] ^ s[19] ^ s[29] ^ s[39] ^ s[49];
|
|
|
|
|
|
h = c8 ^ ((c2 << 1) | (c3 >>> 31));
|
|
|
l = c9 ^ ((c3 << 1) | (c2 >>> 31));
|
|
|
s[0] ^= h;
|
|
|
s[1] ^= l;
|
|
|
s[10] ^= h;
|
|
|
s[11] ^= l;
|
|
|
s[20] ^= h;
|
|
|
s[21] ^= l;
|
|
|
s[30] ^= h;
|
|
|
s[31] ^= l;
|
|
|
s[40] ^= h;
|
|
|
s[41] ^= l;
|
|
|
h = c0 ^ ((c4 << 1) | (c5 >>> 31));
|
|
|
l = c1 ^ ((c5 << 1) | (c4 >>> 31));
|
|
|
s[2] ^= h;
|
|
|
s[3] ^= l;
|
|
|
s[12] ^= h;
|
|
|
s[13] ^= l;
|
|
|
s[22] ^= h;
|
|
|
s[23] ^= l;
|
|
|
s[32] ^= h;
|
|
|
s[33] ^= l;
|
|
|
s[42] ^= h;
|
|
|
s[43] ^= l;
|
|
|
h = c2 ^ ((c6 << 1) | (c7 >>> 31));
|
|
|
l = c3 ^ ((c7 << 1) | (c6 >>> 31));
|
|
|
s[4] ^= h;
|
|
|
s[5] ^= l;
|
|
|
s[14] ^= h;
|
|
|
s[15] ^= l;
|
|
|
s[24] ^= h;
|
|
|
s[25] ^= l;
|
|
|
s[34] ^= h;
|
|
|
s[35] ^= l;
|
|
|
s[44] ^= h;
|
|
|
s[45] ^= l;
|
|
|
h = c4 ^ ((c8 << 1) | (c9 >>> 31));
|
|
|
l = c5 ^ ((c9 << 1) | (c8 >>> 31));
|
|
|
s[6] ^= h;
|
|
|
s[7] ^= l;
|
|
|
s[16] ^= h;
|
|
|
s[17] ^= l;
|
|
|
s[26] ^= h;
|
|
|
s[27] ^= l;
|
|
|
s[36] ^= h;
|
|
|
s[37] ^= l;
|
|
|
s[46] ^= h;
|
|
|
s[47] ^= l;
|
|
|
h = c6 ^ ((c0 << 1) | (c1 >>> 31));
|
|
|
l = c7 ^ ((c1 << 1) | (c0 >>> 31));
|
|
|
s[8] ^= h;
|
|
|
s[9] ^= l;
|
|
|
s[18] ^= h;
|
|
|
s[19] ^= l;
|
|
|
s[28] ^= h;
|
|
|
s[29] ^= l;
|
|
|
s[38] ^= h;
|
|
|
s[39] ^= l;
|
|
|
s[48] ^= h;
|
|
|
s[49] ^= l;
|
|
|
|
|
|
b0 = s[0];
|
|
|
b1 = s[1];
|
|
|
b32 = (s[11] << 4) | (s[10] >>> 28);
|
|
|
b33 = (s[10] << 4) | (s[11] >>> 28);
|
|
|
b14 = (s[20] << 3) | (s[21] >>> 29);
|
|
|
b15 = (s[21] << 3) | (s[20] >>> 29);
|
|
|
b46 = (s[31] << 9) | (s[30] >>> 23);
|
|
|
b47 = (s[30] << 9) | (s[31] >>> 23);
|
|
|
b28 = (s[40] << 18) | (s[41] >>> 14);
|
|
|
b29 = (s[41] << 18) | (s[40] >>> 14);
|
|
|
b20 = (s[2] << 1) | (s[3] >>> 31);
|
|
|
b21 = (s[3] << 1) | (s[2] >>> 31);
|
|
|
b2 = (s[13] << 12) | (s[12] >>> 20);
|
|
|
b3 = (s[12] << 12) | (s[13] >>> 20);
|
|
|
b34 = (s[22] << 10) | (s[23] >>> 22);
|
|
|
b35 = (s[23] << 10) | (s[22] >>> 22);
|
|
|
b16 = (s[33] << 13) | (s[32] >>> 19);
|
|
|
b17 = (s[32] << 13) | (s[33] >>> 19);
|
|
|
b48 = (s[42] << 2) | (s[43] >>> 30);
|
|
|
b49 = (s[43] << 2) | (s[42] >>> 30);
|
|
|
b40 = (s[5] << 30) | (s[4] >>> 2);
|
|
|
b41 = (s[4] << 30) | (s[5] >>> 2);
|
|
|
b22 = (s[14] << 6) | (s[15] >>> 26);
|
|
|
b23 = (s[15] << 6) | (s[14] >>> 26);
|
|
|
b4 = (s[25] << 11) | (s[24] >>> 21);
|
|
|
b5 = (s[24] << 11) | (s[25] >>> 21);
|
|
|
b36 = (s[34] << 15) | (s[35] >>> 17);
|
|
|
b37 = (s[35] << 15) | (s[34] >>> 17);
|
|
|
b18 = (s[45] << 29) | (s[44] >>> 3);
|
|
|
b19 = (s[44] << 29) | (s[45] >>> 3);
|
|
|
b10 = (s[6] << 28) | (s[7] >>> 4);
|
|
|
b11 = (s[7] << 28) | (s[6] >>> 4);
|
|
|
b42 = (s[17] << 23) | (s[16] >>> 9);
|
|
|
b43 = (s[16] << 23) | (s[17] >>> 9);
|
|
|
b24 = (s[26] << 25) | (s[27] >>> 7);
|
|
|
b25 = (s[27] << 25) | (s[26] >>> 7);
|
|
|
b6 = (s[36] << 21) | (s[37] >>> 11);
|
|
|
b7 = (s[37] << 21) | (s[36] >>> 11);
|
|
|
b38 = (s[47] << 24) | (s[46] >>> 8);
|
|
|
b39 = (s[46] << 24) | (s[47] >>> 8);
|
|
|
b30 = (s[8] << 27) | (s[9] >>> 5);
|
|
|
b31 = (s[9] << 27) | (s[8] >>> 5);
|
|
|
b12 = (s[18] << 20) | (s[19] >>> 12);
|
|
|
b13 = (s[19] << 20) | (s[18] >>> 12);
|
|
|
b44 = (s[29] << 7) | (s[28] >>> 25);
|
|
|
b45 = (s[28] << 7) | (s[29] >>> 25);
|
|
|
b26 = (s[38] << 8) | (s[39] >>> 24);
|
|
|
b27 = (s[39] << 8) | (s[38] >>> 24);
|
|
|
b8 = (s[48] << 14) | (s[49] >>> 18);
|
|
|
b9 = (s[49] << 14) | (s[48] >>> 18);
|
|
|
|
|
|
s[0] = b0 ^ (~b2 & b4);
|
|
|
s[1] = b1 ^ (~b3 & b5);
|
|
|
s[10] = b10 ^ (~b12 & b14);
|
|
|
s[11] = b11 ^ (~b13 & b15);
|
|
|
s[20] = b20 ^ (~b22 & b24);
|
|
|
s[21] = b21 ^ (~b23 & b25);
|
|
|
s[30] = b30 ^ (~b32 & b34);
|
|
|
s[31] = b31 ^ (~b33 & b35);
|
|
|
s[40] = b40 ^ (~b42 & b44);
|
|
|
s[41] = b41 ^ (~b43 & b45);
|
|
|
s[2] = b2 ^ (~b4 & b6);
|
|
|
s[3] = b3 ^ (~b5 & b7);
|
|
|
s[12] = b12 ^ (~b14 & b16);
|
|
|
s[13] = b13 ^ (~b15 & b17);
|
|
|
s[22] = b22 ^ (~b24 & b26);
|
|
|
s[23] = b23 ^ (~b25 & b27);
|
|
|
s[32] = b32 ^ (~b34 & b36);
|
|
|
s[33] = b33 ^ (~b35 & b37);
|
|
|
s[42] = b42 ^ (~b44 & b46);
|
|
|
s[43] = b43 ^ (~b45 & b47);
|
|
|
s[4] = b4 ^ (~b6 & b8);
|
|
|
s[5] = b5 ^ (~b7 & b9);
|
|
|
s[14] = b14 ^ (~b16 & b18);
|
|
|
s[15] = b15 ^ (~b17 & b19);
|
|
|
s[24] = b24 ^ (~b26 & b28);
|
|
|
s[25] = b25 ^ (~b27 & b29);
|
|
|
s[34] = b34 ^ (~b36 & b38);
|
|
|
s[35] = b35 ^ (~b37 & b39);
|
|
|
s[44] = b44 ^ (~b46 & b48);
|
|
|
s[45] = b45 ^ (~b47 & b49);
|
|
|
s[6] = b6 ^ (~b8 & b0);
|
|
|
s[7] = b7 ^ (~b9 & b1);
|
|
|
s[16] = b16 ^ (~b18 & b10);
|
|
|
s[17] = b17 ^ (~b19 & b11);
|
|
|
s[26] = b26 ^ (~b28 & b20);
|
|
|
s[27] = b27 ^ (~b29 & b21);
|
|
|
s[36] = b36 ^ (~b38 & b30);
|
|
|
s[37] = b37 ^ (~b39 & b31);
|
|
|
s[46] = b46 ^ (~b48 & b40);
|
|
|
s[47] = b47 ^ (~b49 & b41);
|
|
|
s[8] = b8 ^ (~b0 & b2);
|
|
|
s[9] = b9 ^ (~b1 & b3);
|
|
|
s[18] = b18 ^ (~b10 & b12);
|
|
|
s[19] = b19 ^ (~b11 & b13);
|
|
|
s[28] = b28 ^ (~b20 & b22);
|
|
|
s[29] = b29 ^ (~b21 & b23);
|
|
|
s[38] = b38 ^ (~b30 & b32);
|
|
|
s[39] = b39 ^ (~b31 & b33);
|
|
|
s[48] = b48 ^ (~b40 & b42);
|
|
|
s[49] = b49 ^ (~b41 & b43);
|
|
|
|
|
|
s[0] ^= RC[n];
|
|
|
s[1] ^= RC[n + 1];
|
|
|
}
|
|
|
};
|
|
|
|
|
|
if (COMMON_JS) {
|
|
|
module.exports = methods;
|
|
|
} else {
|
|
|
for (var i = 0; i < methodNames.length; ++i) {
|
|
|
root[methodNames[i]] = methods[methodNames[i]];
|
|
|
}
|
|
|
}
|
|
|
})();
|
|
|
|
|
|
}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
|
},{"_process":4}]},{},[6])(6)
|
|
|
}); |